uunit 0.1.0

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use core::prelude::rust_2021::*;
#[macro_use]
extern crate core;
extern crate compiler_builtins as _;
use core::ops::{
    Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, RemAssign, Sub, SubAssign,
};
use paste::paste;
pub struct Quantity<T, U> {
    pub value: T,
    pub unit: U,
}
#[automatically_derived]
impl<T: ::core::fmt::Debug, U: ::core::fmt::Debug> ::core::fmt::Debug
for Quantity<T, U> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(
            f,
            "Quantity",
            "value",
            &self.value,
            "unit",
            &&self.unit,
        )
    }
}
#[automatically_derived]
impl<T: ::core::clone::Clone, U: ::core::clone::Clone> ::core::clone::Clone
for Quantity<T, U> {
    #[inline]
    fn clone(&self) -> Quantity<T, U> {
        Quantity {
            value: ::core::clone::Clone::clone(&self.value),
            unit: ::core::clone::Clone::clone(&self.unit),
        }
    }
}
#[automatically_derived]
impl<T: ::core::marker::Copy, U: ::core::marker::Copy> ::core::marker::Copy
for Quantity<T, U> {}
impl<T, U> Quantity<T, U> {
    pub fn new(value: T, unit: U) -> Self {
        Quantity { value, unit }
    }
}
impl<U> From<Quantity<i8, U>> for i8 {
    fn from(value: Quantity<i8, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<i16, U>> for i16 {
    fn from(value: Quantity<i16, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<i32, U>> for i32 {
    fn from(value: Quantity<i32, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<i64, U>> for i64 {
    fn from(value: Quantity<i64, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<i128, U>> for i128 {
    fn from(value: Quantity<i128, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<isize, U>> for isize {
    fn from(value: Quantity<isize, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<u8, U>> for u8 {
    fn from(value: Quantity<u8, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<u16, U>> for u16 {
    fn from(value: Quantity<u16, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<u32, U>> for u32 {
    fn from(value: Quantity<u32, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<u64, U>> for u64 {
    fn from(value: Quantity<u64, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<u128, U>> for u128 {
    fn from(value: Quantity<u128, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<usize, U>> for usize {
    fn from(value: Quantity<usize, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<f32, U>> for f32 {
    fn from(value: Quantity<f32, U>) -> Self {
        value.value
    }
}
impl<U> From<Quantity<f64, U>> for f64 {
    fn from(value: Quantity<f64, U>) -> Self {
        value.value
    }
}
impl<T: Add<T>, U: Add<U>> Add<Quantity<T, U>> for Quantity<T, U> {
    type Output = Quantity<<T as Add<T>>::Output, <U as Add<U>>::Output>;
    fn add(self, rhs: Quantity<T, U>) -> Self::Output {
        Quantity::new(self.value.add(rhs.value), self.unit.add(rhs.unit))
    }
}
impl<T: AddAssign<T>, U: AddAssign<U>> AddAssign<Quantity<T, U>> for Quantity<T, U> {
    fn add_assign(&mut self, rhs: Quantity<T, U>) {
        self.value.add_assign(rhs.value);
        self.unit.add_assign(rhs.unit);
    }
}
impl<T: Sub<T>, U: Sub<U>> Sub<Quantity<T, U>> for Quantity<T, U> {
    type Output = Quantity<<T as Sub<T>>::Output, <U as Sub<U>>::Output>;
    fn sub(self, rhs: Quantity<T, U>) -> Self::Output {
        Quantity::new(self.value.sub(rhs.value), self.unit.sub(rhs.unit))
    }
}
impl<T: SubAssign<T>, U: SubAssign<U>> SubAssign<Quantity<T, U>> for Quantity<T, U> {
    fn sub_assign(&mut self, rhs: Quantity<T, U>) {
        self.value.sub_assign(rhs.value);
        self.unit.sub_assign(rhs.unit);
    }
}
impl<T: Mul<T>, U: Mul<U>> Mul<Quantity<T, U>> for Quantity<T, U> {
    type Output = Quantity<<T as Mul<T>>::Output, <U as Mul<U>>::Output>;
    fn mul(self, rhs: Quantity<T, U>) -> Self::Output {
        Quantity::new(self.value.mul(rhs.value), self.unit.mul(rhs.unit))
    }
}
impl<T: MulAssign<T>, U: MulAssign<U>> MulAssign<Quantity<T, U>> for Quantity<T, U> {
    fn mul_assign(&mut self, rhs: Quantity<T, U>) {
        self.value.mul_assign(rhs.value);
        self.unit.mul_assign(rhs.unit);
    }
}
impl<T: Div<T>, U: Div<U>> Div<Quantity<T, U>> for Quantity<T, U> {
    type Output = Quantity<<T as Div<T>>::Output, <U as Div<U>>::Output>;
    fn div(self, rhs: Quantity<T, U>) -> Self::Output {
        Quantity::new(self.value.div(rhs.value), self.unit.div(rhs.unit))
    }
}
impl<T: DivAssign<T>, U: DivAssign<U>> DivAssign<Quantity<T, U>> for Quantity<T, U> {
    fn div_assign(&mut self, rhs: Quantity<T, U>) {
        self.value.div_assign(rhs.value);
        self.unit.div_assign(rhs.unit);
    }
}
impl<T: Rem<T>, U: Rem<U>> Rem<Quantity<T, U>> for Quantity<T, U> {
    type Output = Quantity<<T as Rem<T>>::Output, <U as Rem<U>>::Output>;
    fn rem(self, rhs: Quantity<T, U>) -> Self::Output {
        Quantity::new(self.value.rem(rhs.value), self.unit.rem(rhs.unit))
    }
}
impl<T: RemAssign<T>, U: RemAssign<U>> RemAssign<Quantity<T, U>> for Quantity<T, U> {
    fn rem_assign(&mut self, rhs: Quantity<T, U>) {
        self.value.rem_assign(rhs.value);
        self.unit.rem_assign(rhs.unit);
    }
}
pub struct UnitSeconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSeconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSeconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSeconds {
    #[inline]
    fn clone(&self) -> UnitSeconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSeconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSeconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSeconds {
    #[inline]
    fn eq(&self, other: &UnitSeconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSeconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitSeconds {
    fn default() -> Self {
        UnitSeconds
    }
}
impl Add<UnitSeconds> for UnitSeconds {
    type Output = UnitSeconds;
    #[inline]
    fn add(self, _: UnitSeconds) -> Self::Output {
        UnitSeconds
    }
}
impl AddAssign<UnitSeconds> for UnitSeconds {
    #[inline]
    fn add_assign(&mut self, _: UnitSeconds) {}
}
impl Sub<UnitSeconds> for UnitSeconds {
    type Output = UnitSeconds;
    #[inline]
    fn sub(self, _: UnitSeconds) -> Self::Output {
        UnitSeconds
    }
}
impl SubAssign<UnitSeconds> for UnitSeconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitSeconds) {}
}
pub struct UnitSecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSecondsMul {
    #[inline]
    fn clone(&self) -> UnitSecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSecondsMul {
    #[inline]
    fn eq(&self, other: &UnitSecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitSecondsMul> for i8 {
    type Output = Quantity<i8, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for i16 {
    type Output = Quantity<i16, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for i32 {
    type Output = Quantity<i32, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for i64 {
    type Output = Quantity<i64, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for i128 {
    type Output = Quantity<i128, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for isize {
    type Output = Quantity<isize, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for u8 {
    type Output = Quantity<u8, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for u16 {
    type Output = Quantity<u16, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for u32 {
    type Output = Quantity<u32, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for u64 {
    type Output = Quantity<u64, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for u128 {
    type Output = Quantity<u128, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for usize {
    type Output = Quantity<usize, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for f32 {
    type Output = Quantity<f32, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
impl Mul<UnitSecondsMul> for f64 {
    type Output = Quantity<f64, UnitSeconds>;
    fn mul(self, _: UnitSecondsMul) -> Self::Output {
        Quantity::new(self, UnitSeconds)
    }
}
pub struct UnitQuettaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaseconds {
    #[inline]
    fn clone(&self) -> UnitQuettaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaseconds {
    #[inline]
    fn eq(&self, other: &UnitQuettaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaseconds {
    fn default() -> Self {
        UnitQuettaseconds
    }
}
impl Add<UnitQuettaseconds> for UnitQuettaseconds {
    type Output = UnitQuettaseconds;
    #[inline]
    fn add(self, _: UnitQuettaseconds) -> Self::Output {
        UnitQuettaseconds
    }
}
impl AddAssign<UnitQuettaseconds> for UnitQuettaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaseconds) {}
}
impl Sub<UnitQuettaseconds> for UnitQuettaseconds {
    type Output = UnitQuettaseconds;
    #[inline]
    fn sub(self, _: UnitQuettaseconds) -> Self::Output {
        UnitQuettaseconds
    }
}
impl SubAssign<UnitQuettaseconds> for UnitQuettaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaseconds) {}
}
pub struct UnitQuettasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasecondsMul {
    #[inline]
    fn clone(&self) -> UnitQuettasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettasecondsMul> for i8 {
    type Output = Quantity<i8, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for i16 {
    type Output = Quantity<i16, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for i32 {
    type Output = Quantity<i32, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for i64 {
    type Output = Quantity<i64, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for i128 {
    type Output = Quantity<i128, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for isize {
    type Output = Quantity<isize, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for u8 {
    type Output = Quantity<u8, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for u16 {
    type Output = Quantity<u16, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for u32 {
    type Output = Quantity<u32, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for u64 {
    type Output = Quantity<u64, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for u128 {
    type Output = Quantity<u128, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for usize {
    type Output = Quantity<usize, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for f32 {
    type Output = Quantity<f32, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
impl Mul<UnitQuettasecondsMul> for f64 {
    type Output = Quantity<f64, UnitQuettaseconds>;
    fn mul(self, _: UnitQuettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaseconds)
    }
}
pub struct UnitRonnaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaseconds {
    #[inline]
    fn clone(&self) -> UnitRonnaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaseconds {
    #[inline]
    fn eq(&self, other: &UnitRonnaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaseconds {
    fn default() -> Self {
        UnitRonnaseconds
    }
}
impl Add<UnitRonnaseconds> for UnitRonnaseconds {
    type Output = UnitRonnaseconds;
    #[inline]
    fn add(self, _: UnitRonnaseconds) -> Self::Output {
        UnitRonnaseconds
    }
}
impl AddAssign<UnitRonnaseconds> for UnitRonnaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaseconds) {}
}
impl Sub<UnitRonnaseconds> for UnitRonnaseconds {
    type Output = UnitRonnaseconds;
    #[inline]
    fn sub(self, _: UnitRonnaseconds) -> Self::Output {
        UnitRonnaseconds
    }
}
impl SubAssign<UnitRonnaseconds> for UnitRonnaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaseconds) {}
}
pub struct UnitRonnasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasecondsMul {
    #[inline]
    fn clone(&self) -> UnitRonnasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnasecondsMul> for i8 {
    type Output = Quantity<i8, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for i16 {
    type Output = Quantity<i16, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for i32 {
    type Output = Quantity<i32, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for i64 {
    type Output = Quantity<i64, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for i128 {
    type Output = Quantity<i128, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for isize {
    type Output = Quantity<isize, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for u8 {
    type Output = Quantity<u8, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for u16 {
    type Output = Quantity<u16, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for u32 {
    type Output = Quantity<u32, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for u64 {
    type Output = Quantity<u64, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for u128 {
    type Output = Quantity<u128, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for usize {
    type Output = Quantity<usize, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for f32 {
    type Output = Quantity<f32, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
impl Mul<UnitRonnasecondsMul> for f64 {
    type Output = Quantity<f64, UnitRonnaseconds>;
    fn mul(self, _: UnitRonnasecondsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaseconds)
    }
}
pub struct UnitYottaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaseconds {
    #[inline]
    fn clone(&self) -> UnitYottaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaseconds {
    #[inline]
    fn eq(&self, other: &UnitYottaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaseconds {
    fn default() -> Self {
        UnitYottaseconds
    }
}
impl Add<UnitYottaseconds> for UnitYottaseconds {
    type Output = UnitYottaseconds;
    #[inline]
    fn add(self, _: UnitYottaseconds) -> Self::Output {
        UnitYottaseconds
    }
}
impl AddAssign<UnitYottaseconds> for UnitYottaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaseconds) {}
}
impl Sub<UnitYottaseconds> for UnitYottaseconds {
    type Output = UnitYottaseconds;
    #[inline]
    fn sub(self, _: UnitYottaseconds) -> Self::Output {
        UnitYottaseconds
    }
}
impl SubAssign<UnitYottaseconds> for UnitYottaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaseconds) {}
}
pub struct UnitYottasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasecondsMul {
    #[inline]
    fn clone(&self) -> UnitYottasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitYottasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottasecondsMul> for i8 {
    type Output = Quantity<i8, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for i16 {
    type Output = Quantity<i16, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for i32 {
    type Output = Quantity<i32, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for i64 {
    type Output = Quantity<i64, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for i128 {
    type Output = Quantity<i128, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for isize {
    type Output = Quantity<isize, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for u8 {
    type Output = Quantity<u8, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for u16 {
    type Output = Quantity<u16, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for u32 {
    type Output = Quantity<u32, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for u64 {
    type Output = Quantity<u64, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for u128 {
    type Output = Quantity<u128, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for usize {
    type Output = Quantity<usize, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for f32 {
    type Output = Quantity<f32, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
impl Mul<UnitYottasecondsMul> for f64 {
    type Output = Quantity<f64, UnitYottaseconds>;
    fn mul(self, _: UnitYottasecondsMul) -> Self::Output {
        Quantity::new(self, UnitYottaseconds)
    }
}
pub struct UnitZettaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaseconds {
    #[inline]
    fn clone(&self) -> UnitZettaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaseconds {
    #[inline]
    fn eq(&self, other: &UnitZettaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaseconds {
    fn default() -> Self {
        UnitZettaseconds
    }
}
impl Add<UnitZettaseconds> for UnitZettaseconds {
    type Output = UnitZettaseconds;
    #[inline]
    fn add(self, _: UnitZettaseconds) -> Self::Output {
        UnitZettaseconds
    }
}
impl AddAssign<UnitZettaseconds> for UnitZettaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaseconds) {}
}
impl Sub<UnitZettaseconds> for UnitZettaseconds {
    type Output = UnitZettaseconds;
    #[inline]
    fn sub(self, _: UnitZettaseconds) -> Self::Output {
        UnitZettaseconds
    }
}
impl SubAssign<UnitZettaseconds> for UnitZettaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaseconds) {}
}
pub struct UnitZettasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasecondsMul {
    #[inline]
    fn clone(&self) -> UnitZettasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitZettasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettasecondsMul> for i8 {
    type Output = Quantity<i8, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for i16 {
    type Output = Quantity<i16, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for i32 {
    type Output = Quantity<i32, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for i64 {
    type Output = Quantity<i64, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for i128 {
    type Output = Quantity<i128, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for isize {
    type Output = Quantity<isize, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for u8 {
    type Output = Quantity<u8, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for u16 {
    type Output = Quantity<u16, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for u32 {
    type Output = Quantity<u32, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for u64 {
    type Output = Quantity<u64, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for u128 {
    type Output = Quantity<u128, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for usize {
    type Output = Quantity<usize, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for f32 {
    type Output = Quantity<f32, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
impl Mul<UnitZettasecondsMul> for f64 {
    type Output = Quantity<f64, UnitZettaseconds>;
    fn mul(self, _: UnitZettasecondsMul) -> Self::Output {
        Quantity::new(self, UnitZettaseconds)
    }
}
pub struct UnitExaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaseconds {
    #[inline]
    fn clone(&self) -> UnitExaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaseconds {
    #[inline]
    fn eq(&self, other: &UnitExaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaseconds {
    fn default() -> Self {
        UnitExaseconds
    }
}
impl Add<UnitExaseconds> for UnitExaseconds {
    type Output = UnitExaseconds;
    #[inline]
    fn add(self, _: UnitExaseconds) -> Self::Output {
        UnitExaseconds
    }
}
impl AddAssign<UnitExaseconds> for UnitExaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitExaseconds) {}
}
impl Sub<UnitExaseconds> for UnitExaseconds {
    type Output = UnitExaseconds;
    #[inline]
    fn sub(self, _: UnitExaseconds) -> Self::Output {
        UnitExaseconds
    }
}
impl SubAssign<UnitExaseconds> for UnitExaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaseconds) {}
}
pub struct UnitExasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasecondsMul {
    #[inline]
    fn clone(&self) -> UnitExasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitExasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExasecondsMul> for i8 {
    type Output = Quantity<i8, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for i16 {
    type Output = Quantity<i16, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for i32 {
    type Output = Quantity<i32, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for i64 {
    type Output = Quantity<i64, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for i128 {
    type Output = Quantity<i128, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for isize {
    type Output = Quantity<isize, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for u8 {
    type Output = Quantity<u8, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for u16 {
    type Output = Quantity<u16, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for u32 {
    type Output = Quantity<u32, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for u64 {
    type Output = Quantity<u64, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for u128 {
    type Output = Quantity<u128, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for usize {
    type Output = Quantity<usize, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for f32 {
    type Output = Quantity<f32, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
impl Mul<UnitExasecondsMul> for f64 {
    type Output = Quantity<f64, UnitExaseconds>;
    fn mul(self, _: UnitExasecondsMul) -> Self::Output {
        Quantity::new(self, UnitExaseconds)
    }
}
pub struct UnitPetaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaseconds {
    #[inline]
    fn clone(&self) -> UnitPetaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaseconds {
    #[inline]
    fn eq(&self, other: &UnitPetaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaseconds {
    fn default() -> Self {
        UnitPetaseconds
    }
}
impl Add<UnitPetaseconds> for UnitPetaseconds {
    type Output = UnitPetaseconds;
    #[inline]
    fn add(self, _: UnitPetaseconds) -> Self::Output {
        UnitPetaseconds
    }
}
impl AddAssign<UnitPetaseconds> for UnitPetaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaseconds) {}
}
impl Sub<UnitPetaseconds> for UnitPetaseconds {
    type Output = UnitPetaseconds;
    #[inline]
    fn sub(self, _: UnitPetaseconds) -> Self::Output {
        UnitPetaseconds
    }
}
impl SubAssign<UnitPetaseconds> for UnitPetaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaseconds) {}
}
pub struct UnitPetasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasecondsMul {
    #[inline]
    fn clone(&self) -> UnitPetasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitPetasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetasecondsMul> for i8 {
    type Output = Quantity<i8, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for i16 {
    type Output = Quantity<i16, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for i32 {
    type Output = Quantity<i32, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for i64 {
    type Output = Quantity<i64, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for i128 {
    type Output = Quantity<i128, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for isize {
    type Output = Quantity<isize, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for u8 {
    type Output = Quantity<u8, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for u16 {
    type Output = Quantity<u16, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for u32 {
    type Output = Quantity<u32, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for u64 {
    type Output = Quantity<u64, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for u128 {
    type Output = Quantity<u128, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for usize {
    type Output = Quantity<usize, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for f32 {
    type Output = Quantity<f32, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
impl Mul<UnitPetasecondsMul> for f64 {
    type Output = Quantity<f64, UnitPetaseconds>;
    fn mul(self, _: UnitPetasecondsMul) -> Self::Output {
        Quantity::new(self, UnitPetaseconds)
    }
}
pub struct UnitTeraseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraseconds {
    #[inline]
    fn clone(&self) -> UnitTeraseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraseconds {
    #[inline]
    fn eq(&self, other: &UnitTeraseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraseconds {
    fn default() -> Self {
        UnitTeraseconds
    }
}
impl Add<UnitTeraseconds> for UnitTeraseconds {
    type Output = UnitTeraseconds;
    #[inline]
    fn add(self, _: UnitTeraseconds) -> Self::Output {
        UnitTeraseconds
    }
}
impl AddAssign<UnitTeraseconds> for UnitTeraseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraseconds) {}
}
impl Sub<UnitTeraseconds> for UnitTeraseconds {
    type Output = UnitTeraseconds;
    #[inline]
    fn sub(self, _: UnitTeraseconds) -> Self::Output {
        UnitTeraseconds
    }
}
impl SubAssign<UnitTeraseconds> for UnitTeraseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraseconds) {}
}
pub struct UnitTerasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasecondsMul {
    #[inline]
    fn clone(&self) -> UnitTerasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitTerasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerasecondsMul> for i8 {
    type Output = Quantity<i8, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for i16 {
    type Output = Quantity<i16, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for i32 {
    type Output = Quantity<i32, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for i64 {
    type Output = Quantity<i64, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for i128 {
    type Output = Quantity<i128, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for isize {
    type Output = Quantity<isize, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for u8 {
    type Output = Quantity<u8, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for u16 {
    type Output = Quantity<u16, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for u32 {
    type Output = Quantity<u32, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for u64 {
    type Output = Quantity<u64, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for u128 {
    type Output = Quantity<u128, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for usize {
    type Output = Quantity<usize, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for f32 {
    type Output = Quantity<f32, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
impl Mul<UnitTerasecondsMul> for f64 {
    type Output = Quantity<f64, UnitTeraseconds>;
    fn mul(self, _: UnitTerasecondsMul) -> Self::Output {
        Quantity::new(self, UnitTeraseconds)
    }
}
pub struct UnitGigaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaseconds {
    #[inline]
    fn clone(&self) -> UnitGigaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaseconds {
    #[inline]
    fn eq(&self, other: &UnitGigaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaseconds {
    fn default() -> Self {
        UnitGigaseconds
    }
}
impl Add<UnitGigaseconds> for UnitGigaseconds {
    type Output = UnitGigaseconds;
    #[inline]
    fn add(self, _: UnitGigaseconds) -> Self::Output {
        UnitGigaseconds
    }
}
impl AddAssign<UnitGigaseconds> for UnitGigaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaseconds) {}
}
impl Sub<UnitGigaseconds> for UnitGigaseconds {
    type Output = UnitGigaseconds;
    #[inline]
    fn sub(self, _: UnitGigaseconds) -> Self::Output {
        UnitGigaseconds
    }
}
impl SubAssign<UnitGigaseconds> for UnitGigaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaseconds) {}
}
pub struct UnitGigasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasecondsMul {
    #[inline]
    fn clone(&self) -> UnitGigasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitGigasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigasecondsMul> for i8 {
    type Output = Quantity<i8, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for i16 {
    type Output = Quantity<i16, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for i32 {
    type Output = Quantity<i32, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for i64 {
    type Output = Quantity<i64, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for i128 {
    type Output = Quantity<i128, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for isize {
    type Output = Quantity<isize, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for u8 {
    type Output = Quantity<u8, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for u16 {
    type Output = Quantity<u16, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for u32 {
    type Output = Quantity<u32, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for u64 {
    type Output = Quantity<u64, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for u128 {
    type Output = Quantity<u128, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for usize {
    type Output = Quantity<usize, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for f32 {
    type Output = Quantity<f32, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
impl Mul<UnitGigasecondsMul> for f64 {
    type Output = Quantity<f64, UnitGigaseconds>;
    fn mul(self, _: UnitGigasecondsMul) -> Self::Output {
        Quantity::new(self, UnitGigaseconds)
    }
}
pub struct UnitMegaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaseconds {
    #[inline]
    fn clone(&self) -> UnitMegaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaseconds {
    #[inline]
    fn eq(&self, other: &UnitMegaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaseconds {
    fn default() -> Self {
        UnitMegaseconds
    }
}
impl Add<UnitMegaseconds> for UnitMegaseconds {
    type Output = UnitMegaseconds;
    #[inline]
    fn add(self, _: UnitMegaseconds) -> Self::Output {
        UnitMegaseconds
    }
}
impl AddAssign<UnitMegaseconds> for UnitMegaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaseconds) {}
}
impl Sub<UnitMegaseconds> for UnitMegaseconds {
    type Output = UnitMegaseconds;
    #[inline]
    fn sub(self, _: UnitMegaseconds) -> Self::Output {
        UnitMegaseconds
    }
}
impl SubAssign<UnitMegaseconds> for UnitMegaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaseconds) {}
}
pub struct UnitMegasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasecondsMul {
    #[inline]
    fn clone(&self) -> UnitMegasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitMegasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegasecondsMul> for i8 {
    type Output = Quantity<i8, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for i16 {
    type Output = Quantity<i16, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for i32 {
    type Output = Quantity<i32, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for i64 {
    type Output = Quantity<i64, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for i128 {
    type Output = Quantity<i128, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for isize {
    type Output = Quantity<isize, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for u8 {
    type Output = Quantity<u8, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for u16 {
    type Output = Quantity<u16, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for u32 {
    type Output = Quantity<u32, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for u64 {
    type Output = Quantity<u64, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for u128 {
    type Output = Quantity<u128, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for usize {
    type Output = Quantity<usize, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for f32 {
    type Output = Quantity<f32, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
impl Mul<UnitMegasecondsMul> for f64 {
    type Output = Quantity<f64, UnitMegaseconds>;
    fn mul(self, _: UnitMegasecondsMul) -> Self::Output {
        Quantity::new(self, UnitMegaseconds)
    }
}
pub struct UnitKiloseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloseconds {
    #[inline]
    fn clone(&self) -> UnitKiloseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloseconds {
    #[inline]
    fn eq(&self, other: &UnitKiloseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloseconds {
    fn default() -> Self {
        UnitKiloseconds
    }
}
impl Add<UnitKiloseconds> for UnitKiloseconds {
    type Output = UnitKiloseconds;
    #[inline]
    fn add(self, _: UnitKiloseconds) -> Self::Output {
        UnitKiloseconds
    }
}
impl AddAssign<UnitKiloseconds> for UnitKiloseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloseconds) {}
}
impl Sub<UnitKiloseconds> for UnitKiloseconds {
    type Output = UnitKiloseconds;
    #[inline]
    fn sub(self, _: UnitKiloseconds) -> Self::Output {
        UnitKiloseconds
    }
}
impl SubAssign<UnitKiloseconds> for UnitKiloseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloseconds) {}
}
pub struct UnitKilosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosecondsMul {
    #[inline]
    fn clone(&self) -> UnitKilosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitKilosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilosecondsMul> for i8 {
    type Output = Quantity<i8, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for i16 {
    type Output = Quantity<i16, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for i32 {
    type Output = Quantity<i32, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for i64 {
    type Output = Quantity<i64, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for i128 {
    type Output = Quantity<i128, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for isize {
    type Output = Quantity<isize, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for u8 {
    type Output = Quantity<u8, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for u16 {
    type Output = Quantity<u16, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for u32 {
    type Output = Quantity<u32, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for u64 {
    type Output = Quantity<u64, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for u128 {
    type Output = Quantity<u128, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for usize {
    type Output = Quantity<usize, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for f32 {
    type Output = Quantity<f32, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
impl Mul<UnitKilosecondsMul> for f64 {
    type Output = Quantity<f64, UnitKiloseconds>;
    fn mul(self, _: UnitKilosecondsMul) -> Self::Output {
        Quantity::new(self, UnitKiloseconds)
    }
}
pub struct UnitHectoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoseconds {
    #[inline]
    fn clone(&self) -> UnitHectoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoseconds {
    #[inline]
    fn eq(&self, other: &UnitHectoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoseconds {
    fn default() -> Self {
        UnitHectoseconds
    }
}
impl Add<UnitHectoseconds> for UnitHectoseconds {
    type Output = UnitHectoseconds;
    #[inline]
    fn add(self, _: UnitHectoseconds) -> Self::Output {
        UnitHectoseconds
    }
}
impl AddAssign<UnitHectoseconds> for UnitHectoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoseconds) {}
}
impl Sub<UnitHectoseconds> for UnitHectoseconds {
    type Output = UnitHectoseconds;
    #[inline]
    fn sub(self, _: UnitHectoseconds) -> Self::Output {
        UnitHectoseconds
    }
}
impl SubAssign<UnitHectoseconds> for UnitHectoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoseconds) {}
}
pub struct UnitHectosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosecondsMul {
    #[inline]
    fn clone(&self) -> UnitHectosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitHectosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectosecondsMul> for i8 {
    type Output = Quantity<i8, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for i16 {
    type Output = Quantity<i16, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for i32 {
    type Output = Quantity<i32, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for i64 {
    type Output = Quantity<i64, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for i128 {
    type Output = Quantity<i128, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for isize {
    type Output = Quantity<isize, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for u8 {
    type Output = Quantity<u8, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for u16 {
    type Output = Quantity<u16, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for u32 {
    type Output = Quantity<u32, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for u64 {
    type Output = Quantity<u64, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for u128 {
    type Output = Quantity<u128, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for usize {
    type Output = Quantity<usize, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for f32 {
    type Output = Quantity<f32, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
impl Mul<UnitHectosecondsMul> for f64 {
    type Output = Quantity<f64, UnitHectoseconds>;
    fn mul(self, _: UnitHectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitHectoseconds)
    }
}
pub struct UnitDecaseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaseconds {
    #[inline]
    fn clone(&self) -> UnitDecaseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaseconds {
    #[inline]
    fn eq(&self, other: &UnitDecaseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaseconds {
    fn default() -> Self {
        UnitDecaseconds
    }
}
impl Add<UnitDecaseconds> for UnitDecaseconds {
    type Output = UnitDecaseconds;
    #[inline]
    fn add(self, _: UnitDecaseconds) -> Self::Output {
        UnitDecaseconds
    }
}
impl AddAssign<UnitDecaseconds> for UnitDecaseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaseconds) {}
}
impl Sub<UnitDecaseconds> for UnitDecaseconds {
    type Output = UnitDecaseconds;
    #[inline]
    fn sub(self, _: UnitDecaseconds) -> Self::Output {
        UnitDecaseconds
    }
}
impl SubAssign<UnitDecaseconds> for UnitDecaseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaseconds) {}
}
pub struct UnitDecasecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasecondsMul {
    #[inline]
    fn clone(&self) -> UnitDecasecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasecondsMul {
    #[inline]
    fn eq(&self, other: &UnitDecasecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecasecondsMul> for i8 {
    type Output = Quantity<i8, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for i16 {
    type Output = Quantity<i16, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for i32 {
    type Output = Quantity<i32, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for i64 {
    type Output = Quantity<i64, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for i128 {
    type Output = Quantity<i128, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for isize {
    type Output = Quantity<isize, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for u8 {
    type Output = Quantity<u8, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for u16 {
    type Output = Quantity<u16, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for u32 {
    type Output = Quantity<u32, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for u64 {
    type Output = Quantity<u64, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for u128 {
    type Output = Quantity<u128, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for usize {
    type Output = Quantity<usize, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for f32 {
    type Output = Quantity<f32, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
impl Mul<UnitDecasecondsMul> for f64 {
    type Output = Quantity<f64, UnitDecaseconds>;
    fn mul(self, _: UnitDecasecondsMul) -> Self::Output {
        Quantity::new(self, UnitDecaseconds)
    }
}
pub struct UnitDeciseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciseconds {
    #[inline]
    fn clone(&self) -> UnitDeciseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciseconds {
    #[inline]
    fn eq(&self, other: &UnitDeciseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciseconds {
    fn default() -> Self {
        UnitDeciseconds
    }
}
impl Add<UnitDeciseconds> for UnitDeciseconds {
    type Output = UnitDeciseconds;
    #[inline]
    fn add(self, _: UnitDeciseconds) -> Self::Output {
        UnitDeciseconds
    }
}
impl AddAssign<UnitDeciseconds> for UnitDeciseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciseconds) {}
}
impl Sub<UnitDeciseconds> for UnitDeciseconds {
    type Output = UnitDeciseconds;
    #[inline]
    fn sub(self, _: UnitDeciseconds) -> Self::Output {
        UnitDeciseconds
    }
}
impl SubAssign<UnitDeciseconds> for UnitDeciseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciseconds) {}
}
pub struct UnitDecisecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisecondsMul {
    #[inline]
    fn clone(&self) -> UnitDecisecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisecondsMul {
    #[inline]
    fn eq(&self, other: &UnitDecisecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecisecondsMul> for i8 {
    type Output = Quantity<i8, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for i16 {
    type Output = Quantity<i16, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for i32 {
    type Output = Quantity<i32, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for i64 {
    type Output = Quantity<i64, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for i128 {
    type Output = Quantity<i128, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for isize {
    type Output = Quantity<isize, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for u8 {
    type Output = Quantity<u8, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for u16 {
    type Output = Quantity<u16, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for u32 {
    type Output = Quantity<u32, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for u64 {
    type Output = Quantity<u64, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for u128 {
    type Output = Quantity<u128, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for usize {
    type Output = Quantity<usize, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for f32 {
    type Output = Quantity<f32, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
impl Mul<UnitDecisecondsMul> for f64 {
    type Output = Quantity<f64, UnitDeciseconds>;
    fn mul(self, _: UnitDecisecondsMul) -> Self::Output {
        Quantity::new(self, UnitDeciseconds)
    }
}
pub struct UnitCentiseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiseconds {
    #[inline]
    fn clone(&self) -> UnitCentiseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiseconds {
    #[inline]
    fn eq(&self, other: &UnitCentiseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiseconds {
    fn default() -> Self {
        UnitCentiseconds
    }
}
impl Add<UnitCentiseconds> for UnitCentiseconds {
    type Output = UnitCentiseconds;
    #[inline]
    fn add(self, _: UnitCentiseconds) -> Self::Output {
        UnitCentiseconds
    }
}
impl AddAssign<UnitCentiseconds> for UnitCentiseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiseconds) {}
}
impl Sub<UnitCentiseconds> for UnitCentiseconds {
    type Output = UnitCentiseconds;
    #[inline]
    fn sub(self, _: UnitCentiseconds) -> Self::Output {
        UnitCentiseconds
    }
}
impl SubAssign<UnitCentiseconds> for UnitCentiseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiseconds) {}
}
pub struct UnitCentisecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisecondsMul {
    #[inline]
    fn clone(&self) -> UnitCentisecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisecondsMul {
    #[inline]
    fn eq(&self, other: &UnitCentisecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentisecondsMul> for i8 {
    type Output = Quantity<i8, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for i16 {
    type Output = Quantity<i16, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for i32 {
    type Output = Quantity<i32, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for i64 {
    type Output = Quantity<i64, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for i128 {
    type Output = Quantity<i128, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for isize {
    type Output = Quantity<isize, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for u8 {
    type Output = Quantity<u8, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for u16 {
    type Output = Quantity<u16, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for u32 {
    type Output = Quantity<u32, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for u64 {
    type Output = Quantity<u64, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for u128 {
    type Output = Quantity<u128, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for usize {
    type Output = Quantity<usize, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for f32 {
    type Output = Quantity<f32, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
impl Mul<UnitCentisecondsMul> for f64 {
    type Output = Quantity<f64, UnitCentiseconds>;
    fn mul(self, _: UnitCentisecondsMul) -> Self::Output {
        Quantity::new(self, UnitCentiseconds)
    }
}
pub struct UnitMilliseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliseconds {
    #[inline]
    fn clone(&self) -> UnitMilliseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliseconds {
    #[inline]
    fn eq(&self, other: &UnitMilliseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliseconds {
    fn default() -> Self {
        UnitMilliseconds
    }
}
impl Add<UnitMilliseconds> for UnitMilliseconds {
    type Output = UnitMilliseconds;
    #[inline]
    fn add(self, _: UnitMilliseconds) -> Self::Output {
        UnitMilliseconds
    }
}
impl AddAssign<UnitMilliseconds> for UnitMilliseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliseconds) {}
}
impl Sub<UnitMilliseconds> for UnitMilliseconds {
    type Output = UnitMilliseconds;
    #[inline]
    fn sub(self, _: UnitMilliseconds) -> Self::Output {
        UnitMilliseconds
    }
}
impl SubAssign<UnitMilliseconds> for UnitMilliseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliseconds) {}
}
pub struct UnitMillisecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisecondsMul {
    #[inline]
    fn clone(&self) -> UnitMillisecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisecondsMul {
    #[inline]
    fn eq(&self, other: &UnitMillisecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillisecondsMul> for i8 {
    type Output = Quantity<i8, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for i16 {
    type Output = Quantity<i16, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for i32 {
    type Output = Quantity<i32, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for i64 {
    type Output = Quantity<i64, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for i128 {
    type Output = Quantity<i128, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for isize {
    type Output = Quantity<isize, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for u8 {
    type Output = Quantity<u8, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for u16 {
    type Output = Quantity<u16, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for u32 {
    type Output = Quantity<u32, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for u64 {
    type Output = Quantity<u64, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for u128 {
    type Output = Quantity<u128, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for usize {
    type Output = Quantity<usize, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for f32 {
    type Output = Quantity<f32, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
impl Mul<UnitMillisecondsMul> for f64 {
    type Output = Quantity<f64, UnitMilliseconds>;
    fn mul(self, _: UnitMillisecondsMul) -> Self::Output {
        Quantity::new(self, UnitMilliseconds)
    }
}
pub struct UnitMicroseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroseconds {
    #[inline]
    fn clone(&self) -> UnitMicroseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroseconds {
    #[inline]
    fn eq(&self, other: &UnitMicroseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroseconds {
    fn default() -> Self {
        UnitMicroseconds
    }
}
impl Add<UnitMicroseconds> for UnitMicroseconds {
    type Output = UnitMicroseconds;
    #[inline]
    fn add(self, _: UnitMicroseconds) -> Self::Output {
        UnitMicroseconds
    }
}
impl AddAssign<UnitMicroseconds> for UnitMicroseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroseconds) {}
}
impl Sub<UnitMicroseconds> for UnitMicroseconds {
    type Output = UnitMicroseconds;
    #[inline]
    fn sub(self, _: UnitMicroseconds) -> Self::Output {
        UnitMicroseconds
    }
}
impl SubAssign<UnitMicroseconds> for UnitMicroseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroseconds) {}
}
pub struct UnitMicrosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosecondsMul {
    #[inline]
    fn clone(&self) -> UnitMicrosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrosecondsMul> for i8 {
    type Output = Quantity<i8, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for i16 {
    type Output = Quantity<i16, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for i32 {
    type Output = Quantity<i32, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for i64 {
    type Output = Quantity<i64, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for i128 {
    type Output = Quantity<i128, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for isize {
    type Output = Quantity<isize, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for u8 {
    type Output = Quantity<u8, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for u16 {
    type Output = Quantity<u16, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for u32 {
    type Output = Quantity<u32, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for u64 {
    type Output = Quantity<u64, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for u128 {
    type Output = Quantity<u128, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for usize {
    type Output = Quantity<usize, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for f32 {
    type Output = Quantity<f32, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
impl Mul<UnitMicrosecondsMul> for f64 {
    type Output = Quantity<f64, UnitMicroseconds>;
    fn mul(self, _: UnitMicrosecondsMul) -> Self::Output {
        Quantity::new(self, UnitMicroseconds)
    }
}
pub struct UnitNanoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoseconds {
    #[inline]
    fn clone(&self) -> UnitNanoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoseconds {
    #[inline]
    fn eq(&self, other: &UnitNanoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoseconds {
    fn default() -> Self {
        UnitNanoseconds
    }
}
impl Add<UnitNanoseconds> for UnitNanoseconds {
    type Output = UnitNanoseconds;
    #[inline]
    fn add(self, _: UnitNanoseconds) -> Self::Output {
        UnitNanoseconds
    }
}
impl AddAssign<UnitNanoseconds> for UnitNanoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoseconds) {}
}
impl Sub<UnitNanoseconds> for UnitNanoseconds {
    type Output = UnitNanoseconds;
    #[inline]
    fn sub(self, _: UnitNanoseconds) -> Self::Output {
        UnitNanoseconds
    }
}
impl SubAssign<UnitNanoseconds> for UnitNanoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoseconds) {}
}
pub struct UnitNanosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosecondsMul {
    #[inline]
    fn clone(&self) -> UnitNanosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitNanosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanosecondsMul> for i8 {
    type Output = Quantity<i8, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for i16 {
    type Output = Quantity<i16, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for i32 {
    type Output = Quantity<i32, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for i64 {
    type Output = Quantity<i64, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for i128 {
    type Output = Quantity<i128, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for isize {
    type Output = Quantity<isize, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for u8 {
    type Output = Quantity<u8, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for u16 {
    type Output = Quantity<u16, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for u32 {
    type Output = Quantity<u32, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for u64 {
    type Output = Quantity<u64, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for u128 {
    type Output = Quantity<u128, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for usize {
    type Output = Quantity<usize, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for f32 {
    type Output = Quantity<f32, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
impl Mul<UnitNanosecondsMul> for f64 {
    type Output = Quantity<f64, UnitNanoseconds>;
    fn mul(self, _: UnitNanosecondsMul) -> Self::Output {
        Quantity::new(self, UnitNanoseconds)
    }
}
pub struct UnitPicoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoseconds {
    #[inline]
    fn clone(&self) -> UnitPicoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoseconds {
    #[inline]
    fn eq(&self, other: &UnitPicoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoseconds {
    fn default() -> Self {
        UnitPicoseconds
    }
}
impl Add<UnitPicoseconds> for UnitPicoseconds {
    type Output = UnitPicoseconds;
    #[inline]
    fn add(self, _: UnitPicoseconds) -> Self::Output {
        UnitPicoseconds
    }
}
impl AddAssign<UnitPicoseconds> for UnitPicoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoseconds) {}
}
impl Sub<UnitPicoseconds> for UnitPicoseconds {
    type Output = UnitPicoseconds;
    #[inline]
    fn sub(self, _: UnitPicoseconds) -> Self::Output {
        UnitPicoseconds
    }
}
impl SubAssign<UnitPicoseconds> for UnitPicoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoseconds) {}
}
pub struct UnitPicosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosecondsMul {
    #[inline]
    fn clone(&self) -> UnitPicosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitPicosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicosecondsMul> for i8 {
    type Output = Quantity<i8, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for i16 {
    type Output = Quantity<i16, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for i32 {
    type Output = Quantity<i32, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for i64 {
    type Output = Quantity<i64, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for i128 {
    type Output = Quantity<i128, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for isize {
    type Output = Quantity<isize, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for u8 {
    type Output = Quantity<u8, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for u16 {
    type Output = Quantity<u16, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for u32 {
    type Output = Quantity<u32, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for u64 {
    type Output = Quantity<u64, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for u128 {
    type Output = Quantity<u128, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for usize {
    type Output = Quantity<usize, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for f32 {
    type Output = Quantity<f32, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
impl Mul<UnitPicosecondsMul> for f64 {
    type Output = Quantity<f64, UnitPicoseconds>;
    fn mul(self, _: UnitPicosecondsMul) -> Self::Output {
        Quantity::new(self, UnitPicoseconds)
    }
}
pub struct UnitFemtoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoseconds {
    #[inline]
    fn clone(&self) -> UnitFemtoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoseconds {
    #[inline]
    fn eq(&self, other: &UnitFemtoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoseconds {
    fn default() -> Self {
        UnitFemtoseconds
    }
}
impl Add<UnitFemtoseconds> for UnitFemtoseconds {
    type Output = UnitFemtoseconds;
    #[inline]
    fn add(self, _: UnitFemtoseconds) -> Self::Output {
        UnitFemtoseconds
    }
}
impl AddAssign<UnitFemtoseconds> for UnitFemtoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoseconds) {}
}
impl Sub<UnitFemtoseconds> for UnitFemtoseconds {
    type Output = UnitFemtoseconds;
    #[inline]
    fn sub(self, _: UnitFemtoseconds) -> Self::Output {
        UnitFemtoseconds
    }
}
impl SubAssign<UnitFemtoseconds> for UnitFemtoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoseconds) {}
}
pub struct UnitFemtosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosecondsMul {
    #[inline]
    fn clone(&self) -> UnitFemtosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtosecondsMul> for i8 {
    type Output = Quantity<i8, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for i16 {
    type Output = Quantity<i16, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for i32 {
    type Output = Quantity<i32, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for i64 {
    type Output = Quantity<i64, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for i128 {
    type Output = Quantity<i128, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for isize {
    type Output = Quantity<isize, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for u8 {
    type Output = Quantity<u8, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for u16 {
    type Output = Quantity<u16, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for u32 {
    type Output = Quantity<u32, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for u64 {
    type Output = Quantity<u64, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for u128 {
    type Output = Quantity<u128, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for usize {
    type Output = Quantity<usize, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for f32 {
    type Output = Quantity<f32, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
impl Mul<UnitFemtosecondsMul> for f64 {
    type Output = Quantity<f64, UnitFemtoseconds>;
    fn mul(self, _: UnitFemtosecondsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoseconds)
    }
}
pub struct UnitAttoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoseconds {
    #[inline]
    fn clone(&self) -> UnitAttoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoseconds {
    #[inline]
    fn eq(&self, other: &UnitAttoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoseconds {
    fn default() -> Self {
        UnitAttoseconds
    }
}
impl Add<UnitAttoseconds> for UnitAttoseconds {
    type Output = UnitAttoseconds;
    #[inline]
    fn add(self, _: UnitAttoseconds) -> Self::Output {
        UnitAttoseconds
    }
}
impl AddAssign<UnitAttoseconds> for UnitAttoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoseconds) {}
}
impl Sub<UnitAttoseconds> for UnitAttoseconds {
    type Output = UnitAttoseconds;
    #[inline]
    fn sub(self, _: UnitAttoseconds) -> Self::Output {
        UnitAttoseconds
    }
}
impl SubAssign<UnitAttoseconds> for UnitAttoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoseconds) {}
}
pub struct UnitAttosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosecondsMul {
    #[inline]
    fn clone(&self) -> UnitAttosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitAttosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttosecondsMul> for i8 {
    type Output = Quantity<i8, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for i16 {
    type Output = Quantity<i16, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for i32 {
    type Output = Quantity<i32, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for i64 {
    type Output = Quantity<i64, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for i128 {
    type Output = Quantity<i128, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for isize {
    type Output = Quantity<isize, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for u8 {
    type Output = Quantity<u8, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for u16 {
    type Output = Quantity<u16, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for u32 {
    type Output = Quantity<u32, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for u64 {
    type Output = Quantity<u64, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for u128 {
    type Output = Quantity<u128, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for usize {
    type Output = Quantity<usize, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for f32 {
    type Output = Quantity<f32, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
impl Mul<UnitAttosecondsMul> for f64 {
    type Output = Quantity<f64, UnitAttoseconds>;
    fn mul(self, _: UnitAttosecondsMul) -> Self::Output {
        Quantity::new(self, UnitAttoseconds)
    }
}
pub struct UnitZeptoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoseconds {
    #[inline]
    fn clone(&self) -> UnitZeptoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoseconds {
    #[inline]
    fn eq(&self, other: &UnitZeptoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoseconds {
    fn default() -> Self {
        UnitZeptoseconds
    }
}
impl Add<UnitZeptoseconds> for UnitZeptoseconds {
    type Output = UnitZeptoseconds;
    #[inline]
    fn add(self, _: UnitZeptoseconds) -> Self::Output {
        UnitZeptoseconds
    }
}
impl AddAssign<UnitZeptoseconds> for UnitZeptoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoseconds) {}
}
impl Sub<UnitZeptoseconds> for UnitZeptoseconds {
    type Output = UnitZeptoseconds;
    #[inline]
    fn sub(self, _: UnitZeptoseconds) -> Self::Output {
        UnitZeptoseconds
    }
}
impl SubAssign<UnitZeptoseconds> for UnitZeptoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoseconds) {}
}
pub struct UnitZeptosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosecondsMul {
    #[inline]
    fn clone(&self) -> UnitZeptosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptosecondsMul> for i8 {
    type Output = Quantity<i8, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for i16 {
    type Output = Quantity<i16, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for i32 {
    type Output = Quantity<i32, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for i64 {
    type Output = Quantity<i64, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for i128 {
    type Output = Quantity<i128, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for isize {
    type Output = Quantity<isize, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for u8 {
    type Output = Quantity<u8, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for u16 {
    type Output = Quantity<u16, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for u32 {
    type Output = Quantity<u32, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for u64 {
    type Output = Quantity<u64, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for u128 {
    type Output = Quantity<u128, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for usize {
    type Output = Quantity<usize, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for f32 {
    type Output = Quantity<f32, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
impl Mul<UnitZeptosecondsMul> for f64 {
    type Output = Quantity<f64, UnitZeptoseconds>;
    fn mul(self, _: UnitZeptosecondsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoseconds)
    }
}
pub struct UnitYoctoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoseconds {
    #[inline]
    fn clone(&self) -> UnitYoctoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoseconds {
    #[inline]
    fn eq(&self, other: &UnitYoctoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoseconds {
    fn default() -> Self {
        UnitYoctoseconds
    }
}
impl Add<UnitYoctoseconds> for UnitYoctoseconds {
    type Output = UnitYoctoseconds;
    #[inline]
    fn add(self, _: UnitYoctoseconds) -> Self::Output {
        UnitYoctoseconds
    }
}
impl AddAssign<UnitYoctoseconds> for UnitYoctoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoseconds) {}
}
impl Sub<UnitYoctoseconds> for UnitYoctoseconds {
    type Output = UnitYoctoseconds;
    #[inline]
    fn sub(self, _: UnitYoctoseconds) -> Self::Output {
        UnitYoctoseconds
    }
}
impl SubAssign<UnitYoctoseconds> for UnitYoctoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoseconds) {}
}
pub struct UnitYoctosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosecondsMul {
    #[inline]
    fn clone(&self) -> UnitYoctosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctosecondsMul> for i8 {
    type Output = Quantity<i8, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for i16 {
    type Output = Quantity<i16, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for i32 {
    type Output = Quantity<i32, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for i64 {
    type Output = Quantity<i64, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for i128 {
    type Output = Quantity<i128, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for isize {
    type Output = Quantity<isize, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for u8 {
    type Output = Quantity<u8, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for u16 {
    type Output = Quantity<u16, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for u32 {
    type Output = Quantity<u32, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for u64 {
    type Output = Quantity<u64, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for u128 {
    type Output = Quantity<u128, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for usize {
    type Output = Quantity<usize, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for f32 {
    type Output = Quantity<f32, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
impl Mul<UnitYoctosecondsMul> for f64 {
    type Output = Quantity<f64, UnitYoctoseconds>;
    fn mul(self, _: UnitYoctosecondsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoseconds)
    }
}
pub struct UnitRontoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoseconds {
    #[inline]
    fn clone(&self) -> UnitRontoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoseconds {
    #[inline]
    fn eq(&self, other: &UnitRontoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoseconds {
    fn default() -> Self {
        UnitRontoseconds
    }
}
impl Add<UnitRontoseconds> for UnitRontoseconds {
    type Output = UnitRontoseconds;
    #[inline]
    fn add(self, _: UnitRontoseconds) -> Self::Output {
        UnitRontoseconds
    }
}
impl AddAssign<UnitRontoseconds> for UnitRontoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoseconds) {}
}
impl Sub<UnitRontoseconds> for UnitRontoseconds {
    type Output = UnitRontoseconds;
    #[inline]
    fn sub(self, _: UnitRontoseconds) -> Self::Output {
        UnitRontoseconds
    }
}
impl SubAssign<UnitRontoseconds> for UnitRontoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoseconds) {}
}
pub struct UnitRontosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosecondsMul {
    #[inline]
    fn clone(&self) -> UnitRontosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitRontosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontosecondsMul> for i8 {
    type Output = Quantity<i8, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for i16 {
    type Output = Quantity<i16, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for i32 {
    type Output = Quantity<i32, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for i64 {
    type Output = Quantity<i64, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for i128 {
    type Output = Quantity<i128, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for isize {
    type Output = Quantity<isize, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for u8 {
    type Output = Quantity<u8, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for u16 {
    type Output = Quantity<u16, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for u32 {
    type Output = Quantity<u32, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for u64 {
    type Output = Quantity<u64, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for u128 {
    type Output = Quantity<u128, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for usize {
    type Output = Quantity<usize, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for f32 {
    type Output = Quantity<f32, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
impl Mul<UnitRontosecondsMul> for f64 {
    type Output = Quantity<f64, UnitRontoseconds>;
    fn mul(self, _: UnitRontosecondsMul) -> Self::Output {
        Quantity::new(self, UnitRontoseconds)
    }
}
pub struct UnitQuectoseconds;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoseconds {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoseconds")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoseconds {
    #[inline]
    fn clone(&self) -> UnitQuectoseconds {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoseconds {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoseconds {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoseconds {
    #[inline]
    fn eq(&self, other: &UnitQuectoseconds) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoseconds {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoseconds {
    fn default() -> Self {
        UnitQuectoseconds
    }
}
impl Add<UnitQuectoseconds> for UnitQuectoseconds {
    type Output = UnitQuectoseconds;
    #[inline]
    fn add(self, _: UnitQuectoseconds) -> Self::Output {
        UnitQuectoseconds
    }
}
impl AddAssign<UnitQuectoseconds> for UnitQuectoseconds {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoseconds) {}
}
impl Sub<UnitQuectoseconds> for UnitQuectoseconds {
    type Output = UnitQuectoseconds;
    #[inline]
    fn sub(self, _: UnitQuectoseconds) -> Self::Output {
        UnitQuectoseconds
    }
}
impl SubAssign<UnitQuectoseconds> for UnitQuectoseconds {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoseconds) {}
}
pub struct UnitQuectosecondsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosecondsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosecondsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosecondsMul {
    #[inline]
    fn clone(&self) -> UnitQuectosecondsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosecondsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosecondsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosecondsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectosecondsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosecondsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectosecondsMul> for i8 {
    type Output = Quantity<i8, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for i16 {
    type Output = Quantity<i16, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for i32 {
    type Output = Quantity<i32, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for i64 {
    type Output = Quantity<i64, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for i128 {
    type Output = Quantity<i128, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for isize {
    type Output = Quantity<isize, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for u8 {
    type Output = Quantity<u8, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for u16 {
    type Output = Quantity<u16, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for u32 {
    type Output = Quantity<u32, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for u64 {
    type Output = Quantity<u64, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for u128 {
    type Output = Quantity<u128, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for usize {
    type Output = Quantity<usize, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for f32 {
    type Output = Quantity<f32, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
impl Mul<UnitQuectosecondsMul> for f64 {
    type Output = Quantity<f64, UnitQuectoseconds>;
    fn mul(self, _: UnitQuectosecondsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoseconds)
    }
}
pub type Seconds<T> = Quantity<T, UnitSeconds>;
#[allow(non_upper_case_globals)]
pub static Seconds: UnitSecondsMul = UnitSecondsMul;
pub type Quettaseconds<T> = Quantity<T, UnitQuettaseconds>;
#[allow(non_upper_case_globals)]
pub static Quettaseconds: UnitQuettasecondsMul = UnitQuettasecondsMul;
pub type Ronnaseconds<T> = Quantity<T, UnitRonnaseconds>;
#[allow(non_upper_case_globals)]
pub static Ronnaseconds: UnitRonnasecondsMul = UnitRonnasecondsMul;
pub type Yottaseconds<T> = Quantity<T, UnitYottaseconds>;
#[allow(non_upper_case_globals)]
pub static Yottaseconds: UnitYottasecondsMul = UnitYottasecondsMul;
pub type Zettaseconds<T> = Quantity<T, UnitZettaseconds>;
#[allow(non_upper_case_globals)]
pub static Zettaseconds: UnitZettasecondsMul = UnitZettasecondsMul;
pub type Exaseconds<T> = Quantity<T, UnitExaseconds>;
#[allow(non_upper_case_globals)]
pub static Exaseconds: UnitExasecondsMul = UnitExasecondsMul;
pub type Petaseconds<T> = Quantity<T, UnitPetaseconds>;
#[allow(non_upper_case_globals)]
pub static Petaseconds: UnitPetasecondsMul = UnitPetasecondsMul;
pub type Teraseconds<T> = Quantity<T, UnitTeraseconds>;
#[allow(non_upper_case_globals)]
pub static Teraseconds: UnitTerasecondsMul = UnitTerasecondsMul;
pub type Gigaseconds<T> = Quantity<T, UnitGigaseconds>;
#[allow(non_upper_case_globals)]
pub static Gigaseconds: UnitGigasecondsMul = UnitGigasecondsMul;
pub type Megaseconds<T> = Quantity<T, UnitMegaseconds>;
#[allow(non_upper_case_globals)]
pub static Megaseconds: UnitMegasecondsMul = UnitMegasecondsMul;
pub type Kiloseconds<T> = Quantity<T, UnitKiloseconds>;
#[allow(non_upper_case_globals)]
pub static Kiloseconds: UnitKilosecondsMul = UnitKilosecondsMul;
pub type Hectoseconds<T> = Quantity<T, UnitHectoseconds>;
#[allow(non_upper_case_globals)]
pub static Hectoseconds: UnitHectosecondsMul = UnitHectosecondsMul;
pub type Decaseconds<T> = Quantity<T, UnitDecaseconds>;
#[allow(non_upper_case_globals)]
pub static Decaseconds: UnitDecasecondsMul = UnitDecasecondsMul;
pub type Deciseconds<T> = Quantity<T, UnitDeciseconds>;
#[allow(non_upper_case_globals)]
pub static Deciseconds: UnitDecisecondsMul = UnitDecisecondsMul;
pub type Centiseconds<T> = Quantity<T, UnitCentiseconds>;
#[allow(non_upper_case_globals)]
pub static Centiseconds: UnitCentisecondsMul = UnitCentisecondsMul;
pub type Milliseconds<T> = Quantity<T, UnitMilliseconds>;
#[allow(non_upper_case_globals)]
pub static Milliseconds: UnitMillisecondsMul = UnitMillisecondsMul;
pub type Microseconds<T> = Quantity<T, UnitMicroseconds>;
#[allow(non_upper_case_globals)]
pub static Microseconds: UnitMicrosecondsMul = UnitMicrosecondsMul;
pub type Nanoseconds<T> = Quantity<T, UnitNanoseconds>;
#[allow(non_upper_case_globals)]
pub static Nanoseconds: UnitNanosecondsMul = UnitNanosecondsMul;
pub type Picoseconds<T> = Quantity<T, UnitPicoseconds>;
#[allow(non_upper_case_globals)]
pub static Picoseconds: UnitPicosecondsMul = UnitPicosecondsMul;
pub type Femtoseconds<T> = Quantity<T, UnitFemtoseconds>;
#[allow(non_upper_case_globals)]
pub static Femtoseconds: UnitFemtosecondsMul = UnitFemtosecondsMul;
pub type Attoseconds<T> = Quantity<T, UnitAttoseconds>;
#[allow(non_upper_case_globals)]
pub static Attoseconds: UnitAttosecondsMul = UnitAttosecondsMul;
pub type Zeptoseconds<T> = Quantity<T, UnitZeptoseconds>;
#[allow(non_upper_case_globals)]
pub static Zeptoseconds: UnitZeptosecondsMul = UnitZeptosecondsMul;
pub type Yoctoseconds<T> = Quantity<T, UnitYoctoseconds>;
#[allow(non_upper_case_globals)]
pub static Yoctoseconds: UnitYoctosecondsMul = UnitYoctosecondsMul;
pub type Rontoseconds<T> = Quantity<T, UnitRontoseconds>;
#[allow(non_upper_case_globals)]
pub static Rontoseconds: UnitRontosecondsMul = UnitRontosecondsMul;
pub type Quectoseconds<T> = Quantity<T, UnitQuectoseconds>;
#[allow(non_upper_case_globals)]
pub static Quectoseconds: UnitQuectosecondsMul = UnitQuectosecondsMul;
pub struct UnitMeters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMeters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMeters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMeters {
    #[inline]
    fn clone(&self) -> UnitMeters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMeters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMeters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMeters {
    #[inline]
    fn eq(&self, other: &UnitMeters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMeters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMeters {
    fn default() -> Self {
        UnitMeters
    }
}
impl Add<UnitMeters> for UnitMeters {
    type Output = UnitMeters;
    #[inline]
    fn add(self, _: UnitMeters) -> Self::Output {
        UnitMeters
    }
}
impl AddAssign<UnitMeters> for UnitMeters {
    #[inline]
    fn add_assign(&mut self, _: UnitMeters) {}
}
impl Sub<UnitMeters> for UnitMeters {
    type Output = UnitMeters;
    #[inline]
    fn sub(self, _: UnitMeters) -> Self::Output {
        UnitMeters
    }
}
impl SubAssign<UnitMeters> for UnitMeters {
    #[inline]
    fn sub_assign(&mut self, _: UnitMeters) {}
}
pub struct UnitMetersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMetersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMetersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMetersMul {
    #[inline]
    fn clone(&self) -> UnitMetersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMetersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMetersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMetersMul {
    #[inline]
    fn eq(&self, other: &UnitMetersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMetersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMetersMul> for i8 {
    type Output = Quantity<i8, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for i16 {
    type Output = Quantity<i16, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for i32 {
    type Output = Quantity<i32, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for i64 {
    type Output = Quantity<i64, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for i128 {
    type Output = Quantity<i128, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for isize {
    type Output = Quantity<isize, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for u8 {
    type Output = Quantity<u8, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for u16 {
    type Output = Quantity<u16, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for u32 {
    type Output = Quantity<u32, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for u64 {
    type Output = Quantity<u64, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for u128 {
    type Output = Quantity<u128, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for usize {
    type Output = Quantity<usize, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for f32 {
    type Output = Quantity<f32, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
impl Mul<UnitMetersMul> for f64 {
    type Output = Quantity<f64, UnitMeters>;
    fn mul(self, _: UnitMetersMul) -> Self::Output {
        Quantity::new(self, UnitMeters)
    }
}
pub struct UnitQuettameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettameters {
    #[inline]
    fn clone(&self) -> UnitQuettameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettameters {
    #[inline]
    fn eq(&self, other: &UnitQuettameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettameters {
    fn default() -> Self {
        UnitQuettameters
    }
}
impl Add<UnitQuettameters> for UnitQuettameters {
    type Output = UnitQuettameters;
    #[inline]
    fn add(self, _: UnitQuettameters) -> Self::Output {
        UnitQuettameters
    }
}
impl AddAssign<UnitQuettameters> for UnitQuettameters {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettameters) {}
}
impl Sub<UnitQuettameters> for UnitQuettameters {
    type Output = UnitQuettameters;
    #[inline]
    fn sub(self, _: UnitQuettameters) -> Self::Output {
        UnitQuettameters
    }
}
impl SubAssign<UnitQuettameters> for UnitQuettameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettameters) {}
}
pub struct UnitQuettametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettametersMul {
    #[inline]
    fn clone(&self) -> UnitQuettametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettametersMul {
    #[inline]
    fn eq(&self, other: &UnitQuettametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettametersMul> for i8 {
    type Output = Quantity<i8, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for i16 {
    type Output = Quantity<i16, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for i32 {
    type Output = Quantity<i32, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for i64 {
    type Output = Quantity<i64, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for i128 {
    type Output = Quantity<i128, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for isize {
    type Output = Quantity<isize, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for u8 {
    type Output = Quantity<u8, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for u16 {
    type Output = Quantity<u16, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for u32 {
    type Output = Quantity<u32, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for u64 {
    type Output = Quantity<u64, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for u128 {
    type Output = Quantity<u128, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for usize {
    type Output = Quantity<usize, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for f32 {
    type Output = Quantity<f32, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
impl Mul<UnitQuettametersMul> for f64 {
    type Output = Quantity<f64, UnitQuettameters>;
    fn mul(self, _: UnitQuettametersMul) -> Self::Output {
        Quantity::new(self, UnitQuettameters)
    }
}
pub struct UnitRonnameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnameters {
    #[inline]
    fn clone(&self) -> UnitRonnameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnameters {
    #[inline]
    fn eq(&self, other: &UnitRonnameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnameters {
    fn default() -> Self {
        UnitRonnameters
    }
}
impl Add<UnitRonnameters> for UnitRonnameters {
    type Output = UnitRonnameters;
    #[inline]
    fn add(self, _: UnitRonnameters) -> Self::Output {
        UnitRonnameters
    }
}
impl AddAssign<UnitRonnameters> for UnitRonnameters {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnameters) {}
}
impl Sub<UnitRonnameters> for UnitRonnameters {
    type Output = UnitRonnameters;
    #[inline]
    fn sub(self, _: UnitRonnameters) -> Self::Output {
        UnitRonnameters
    }
}
impl SubAssign<UnitRonnameters> for UnitRonnameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnameters) {}
}
pub struct UnitRonnametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnametersMul {
    #[inline]
    fn clone(&self) -> UnitRonnametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnametersMul {
    #[inline]
    fn eq(&self, other: &UnitRonnametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnametersMul> for i8 {
    type Output = Quantity<i8, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for i16 {
    type Output = Quantity<i16, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for i32 {
    type Output = Quantity<i32, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for i64 {
    type Output = Quantity<i64, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for i128 {
    type Output = Quantity<i128, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for isize {
    type Output = Quantity<isize, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for u8 {
    type Output = Quantity<u8, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for u16 {
    type Output = Quantity<u16, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for u32 {
    type Output = Quantity<u32, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for u64 {
    type Output = Quantity<u64, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for u128 {
    type Output = Quantity<u128, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for usize {
    type Output = Quantity<usize, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for f32 {
    type Output = Quantity<f32, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
impl Mul<UnitRonnametersMul> for f64 {
    type Output = Quantity<f64, UnitRonnameters>;
    fn mul(self, _: UnitRonnametersMul) -> Self::Output {
        Quantity::new(self, UnitRonnameters)
    }
}
pub struct UnitYottameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottameters {
    #[inline]
    fn clone(&self) -> UnitYottameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottameters {
    #[inline]
    fn eq(&self, other: &UnitYottameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottameters {
    fn default() -> Self {
        UnitYottameters
    }
}
impl Add<UnitYottameters> for UnitYottameters {
    type Output = UnitYottameters;
    #[inline]
    fn add(self, _: UnitYottameters) -> Self::Output {
        UnitYottameters
    }
}
impl AddAssign<UnitYottameters> for UnitYottameters {
    #[inline]
    fn add_assign(&mut self, _: UnitYottameters) {}
}
impl Sub<UnitYottameters> for UnitYottameters {
    type Output = UnitYottameters;
    #[inline]
    fn sub(self, _: UnitYottameters) -> Self::Output {
        UnitYottameters
    }
}
impl SubAssign<UnitYottameters> for UnitYottameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottameters) {}
}
pub struct UnitYottametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottametersMul {
    #[inline]
    fn clone(&self) -> UnitYottametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottametersMul {
    #[inline]
    fn eq(&self, other: &UnitYottametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottametersMul> for i8 {
    type Output = Quantity<i8, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for i16 {
    type Output = Quantity<i16, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for i32 {
    type Output = Quantity<i32, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for i64 {
    type Output = Quantity<i64, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for i128 {
    type Output = Quantity<i128, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for isize {
    type Output = Quantity<isize, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for u8 {
    type Output = Quantity<u8, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for u16 {
    type Output = Quantity<u16, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for u32 {
    type Output = Quantity<u32, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for u64 {
    type Output = Quantity<u64, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for u128 {
    type Output = Quantity<u128, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for usize {
    type Output = Quantity<usize, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for f32 {
    type Output = Quantity<f32, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
impl Mul<UnitYottametersMul> for f64 {
    type Output = Quantity<f64, UnitYottameters>;
    fn mul(self, _: UnitYottametersMul) -> Self::Output {
        Quantity::new(self, UnitYottameters)
    }
}
pub struct UnitZettameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettameters {
    #[inline]
    fn clone(&self) -> UnitZettameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettameters {
    #[inline]
    fn eq(&self, other: &UnitZettameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettameters {
    fn default() -> Self {
        UnitZettameters
    }
}
impl Add<UnitZettameters> for UnitZettameters {
    type Output = UnitZettameters;
    #[inline]
    fn add(self, _: UnitZettameters) -> Self::Output {
        UnitZettameters
    }
}
impl AddAssign<UnitZettameters> for UnitZettameters {
    #[inline]
    fn add_assign(&mut self, _: UnitZettameters) {}
}
impl Sub<UnitZettameters> for UnitZettameters {
    type Output = UnitZettameters;
    #[inline]
    fn sub(self, _: UnitZettameters) -> Self::Output {
        UnitZettameters
    }
}
impl SubAssign<UnitZettameters> for UnitZettameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettameters) {}
}
pub struct UnitZettametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettametersMul {
    #[inline]
    fn clone(&self) -> UnitZettametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettametersMul {
    #[inline]
    fn eq(&self, other: &UnitZettametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettametersMul> for i8 {
    type Output = Quantity<i8, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for i16 {
    type Output = Quantity<i16, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for i32 {
    type Output = Quantity<i32, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for i64 {
    type Output = Quantity<i64, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for i128 {
    type Output = Quantity<i128, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for isize {
    type Output = Quantity<isize, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for u8 {
    type Output = Quantity<u8, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for u16 {
    type Output = Quantity<u16, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for u32 {
    type Output = Quantity<u32, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for u64 {
    type Output = Quantity<u64, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for u128 {
    type Output = Quantity<u128, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for usize {
    type Output = Quantity<usize, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for f32 {
    type Output = Quantity<f32, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
impl Mul<UnitZettametersMul> for f64 {
    type Output = Quantity<f64, UnitZettameters>;
    fn mul(self, _: UnitZettametersMul) -> Self::Output {
        Quantity::new(self, UnitZettameters)
    }
}
pub struct UnitExameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExameters {
    #[inline]
    fn clone(&self) -> UnitExameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExameters {
    #[inline]
    fn eq(&self, other: &UnitExameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExameters {
    fn default() -> Self {
        UnitExameters
    }
}
impl Add<UnitExameters> for UnitExameters {
    type Output = UnitExameters;
    #[inline]
    fn add(self, _: UnitExameters) -> Self::Output {
        UnitExameters
    }
}
impl AddAssign<UnitExameters> for UnitExameters {
    #[inline]
    fn add_assign(&mut self, _: UnitExameters) {}
}
impl Sub<UnitExameters> for UnitExameters {
    type Output = UnitExameters;
    #[inline]
    fn sub(self, _: UnitExameters) -> Self::Output {
        UnitExameters
    }
}
impl SubAssign<UnitExameters> for UnitExameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitExameters) {}
}
pub struct UnitExametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExametersMul {
    #[inline]
    fn clone(&self) -> UnitExametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExametersMul {
    #[inline]
    fn eq(&self, other: &UnitExametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExametersMul> for i8 {
    type Output = Quantity<i8, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for i16 {
    type Output = Quantity<i16, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for i32 {
    type Output = Quantity<i32, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for i64 {
    type Output = Quantity<i64, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for i128 {
    type Output = Quantity<i128, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for isize {
    type Output = Quantity<isize, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for u8 {
    type Output = Quantity<u8, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for u16 {
    type Output = Quantity<u16, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for u32 {
    type Output = Quantity<u32, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for u64 {
    type Output = Quantity<u64, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for u128 {
    type Output = Quantity<u128, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for usize {
    type Output = Quantity<usize, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for f32 {
    type Output = Quantity<f32, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
impl Mul<UnitExametersMul> for f64 {
    type Output = Quantity<f64, UnitExameters>;
    fn mul(self, _: UnitExametersMul) -> Self::Output {
        Quantity::new(self, UnitExameters)
    }
}
pub struct UnitPetameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetameters {
    #[inline]
    fn clone(&self) -> UnitPetameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetameters {
    #[inline]
    fn eq(&self, other: &UnitPetameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetameters {
    fn default() -> Self {
        UnitPetameters
    }
}
impl Add<UnitPetameters> for UnitPetameters {
    type Output = UnitPetameters;
    #[inline]
    fn add(self, _: UnitPetameters) -> Self::Output {
        UnitPetameters
    }
}
impl AddAssign<UnitPetameters> for UnitPetameters {
    #[inline]
    fn add_assign(&mut self, _: UnitPetameters) {}
}
impl Sub<UnitPetameters> for UnitPetameters {
    type Output = UnitPetameters;
    #[inline]
    fn sub(self, _: UnitPetameters) -> Self::Output {
        UnitPetameters
    }
}
impl SubAssign<UnitPetameters> for UnitPetameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetameters) {}
}
pub struct UnitPetametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetametersMul {
    #[inline]
    fn clone(&self) -> UnitPetametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetametersMul {
    #[inline]
    fn eq(&self, other: &UnitPetametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetametersMul> for i8 {
    type Output = Quantity<i8, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for i16 {
    type Output = Quantity<i16, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for i32 {
    type Output = Quantity<i32, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for i64 {
    type Output = Quantity<i64, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for i128 {
    type Output = Quantity<i128, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for isize {
    type Output = Quantity<isize, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for u8 {
    type Output = Quantity<u8, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for u16 {
    type Output = Quantity<u16, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for u32 {
    type Output = Quantity<u32, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for u64 {
    type Output = Quantity<u64, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for u128 {
    type Output = Quantity<u128, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for usize {
    type Output = Quantity<usize, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for f32 {
    type Output = Quantity<f32, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
impl Mul<UnitPetametersMul> for f64 {
    type Output = Quantity<f64, UnitPetameters>;
    fn mul(self, _: UnitPetametersMul) -> Self::Output {
        Quantity::new(self, UnitPetameters)
    }
}
pub struct UnitTerameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerameters {
    #[inline]
    fn clone(&self) -> UnitTerameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerameters {
    #[inline]
    fn eq(&self, other: &UnitTerameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerameters {
    fn default() -> Self {
        UnitTerameters
    }
}
impl Add<UnitTerameters> for UnitTerameters {
    type Output = UnitTerameters;
    #[inline]
    fn add(self, _: UnitTerameters) -> Self::Output {
        UnitTerameters
    }
}
impl AddAssign<UnitTerameters> for UnitTerameters {
    #[inline]
    fn add_assign(&mut self, _: UnitTerameters) {}
}
impl Sub<UnitTerameters> for UnitTerameters {
    type Output = UnitTerameters;
    #[inline]
    fn sub(self, _: UnitTerameters) -> Self::Output {
        UnitTerameters
    }
}
impl SubAssign<UnitTerameters> for UnitTerameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerameters) {}
}
pub struct UnitTerametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerametersMul {
    #[inline]
    fn clone(&self) -> UnitTerametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerametersMul {
    #[inline]
    fn eq(&self, other: &UnitTerametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerametersMul> for i8 {
    type Output = Quantity<i8, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for i16 {
    type Output = Quantity<i16, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for i32 {
    type Output = Quantity<i32, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for i64 {
    type Output = Quantity<i64, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for i128 {
    type Output = Quantity<i128, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for isize {
    type Output = Quantity<isize, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for u8 {
    type Output = Quantity<u8, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for u16 {
    type Output = Quantity<u16, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for u32 {
    type Output = Quantity<u32, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for u64 {
    type Output = Quantity<u64, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for u128 {
    type Output = Quantity<u128, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for usize {
    type Output = Quantity<usize, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for f32 {
    type Output = Quantity<f32, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
impl Mul<UnitTerametersMul> for f64 {
    type Output = Quantity<f64, UnitTerameters>;
    fn mul(self, _: UnitTerametersMul) -> Self::Output {
        Quantity::new(self, UnitTerameters)
    }
}
pub struct UnitGigameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigameters {
    #[inline]
    fn clone(&self) -> UnitGigameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigameters {
    #[inline]
    fn eq(&self, other: &UnitGigameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigameters {
    fn default() -> Self {
        UnitGigameters
    }
}
impl Add<UnitGigameters> for UnitGigameters {
    type Output = UnitGigameters;
    #[inline]
    fn add(self, _: UnitGigameters) -> Self::Output {
        UnitGigameters
    }
}
impl AddAssign<UnitGigameters> for UnitGigameters {
    #[inline]
    fn add_assign(&mut self, _: UnitGigameters) {}
}
impl Sub<UnitGigameters> for UnitGigameters {
    type Output = UnitGigameters;
    #[inline]
    fn sub(self, _: UnitGigameters) -> Self::Output {
        UnitGigameters
    }
}
impl SubAssign<UnitGigameters> for UnitGigameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigameters) {}
}
pub struct UnitGigametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigametersMul {
    #[inline]
    fn clone(&self) -> UnitGigametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigametersMul {
    #[inline]
    fn eq(&self, other: &UnitGigametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigametersMul> for i8 {
    type Output = Quantity<i8, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for i16 {
    type Output = Quantity<i16, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for i32 {
    type Output = Quantity<i32, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for i64 {
    type Output = Quantity<i64, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for i128 {
    type Output = Quantity<i128, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for isize {
    type Output = Quantity<isize, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for u8 {
    type Output = Quantity<u8, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for u16 {
    type Output = Quantity<u16, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for u32 {
    type Output = Quantity<u32, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for u64 {
    type Output = Quantity<u64, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for u128 {
    type Output = Quantity<u128, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for usize {
    type Output = Quantity<usize, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for f32 {
    type Output = Quantity<f32, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
impl Mul<UnitGigametersMul> for f64 {
    type Output = Quantity<f64, UnitGigameters>;
    fn mul(self, _: UnitGigametersMul) -> Self::Output {
        Quantity::new(self, UnitGigameters)
    }
}
pub struct UnitMegameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegameters {
    #[inline]
    fn clone(&self) -> UnitMegameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegameters {
    #[inline]
    fn eq(&self, other: &UnitMegameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegameters {
    fn default() -> Self {
        UnitMegameters
    }
}
impl Add<UnitMegameters> for UnitMegameters {
    type Output = UnitMegameters;
    #[inline]
    fn add(self, _: UnitMegameters) -> Self::Output {
        UnitMegameters
    }
}
impl AddAssign<UnitMegameters> for UnitMegameters {
    #[inline]
    fn add_assign(&mut self, _: UnitMegameters) {}
}
impl Sub<UnitMegameters> for UnitMegameters {
    type Output = UnitMegameters;
    #[inline]
    fn sub(self, _: UnitMegameters) -> Self::Output {
        UnitMegameters
    }
}
impl SubAssign<UnitMegameters> for UnitMegameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegameters) {}
}
pub struct UnitMegametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegametersMul {
    #[inline]
    fn clone(&self) -> UnitMegametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegametersMul {
    #[inline]
    fn eq(&self, other: &UnitMegametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegametersMul> for i8 {
    type Output = Quantity<i8, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for i16 {
    type Output = Quantity<i16, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for i32 {
    type Output = Quantity<i32, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for i64 {
    type Output = Quantity<i64, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for i128 {
    type Output = Quantity<i128, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for isize {
    type Output = Quantity<isize, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for u8 {
    type Output = Quantity<u8, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for u16 {
    type Output = Quantity<u16, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for u32 {
    type Output = Quantity<u32, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for u64 {
    type Output = Quantity<u64, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for u128 {
    type Output = Quantity<u128, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for usize {
    type Output = Quantity<usize, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for f32 {
    type Output = Quantity<f32, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
impl Mul<UnitMegametersMul> for f64 {
    type Output = Quantity<f64, UnitMegameters>;
    fn mul(self, _: UnitMegametersMul) -> Self::Output {
        Quantity::new(self, UnitMegameters)
    }
}
pub struct UnitKilometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilometers {
    #[inline]
    fn clone(&self) -> UnitKilometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilometers {
    #[inline]
    fn eq(&self, other: &UnitKilometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilometers {
    fn default() -> Self {
        UnitKilometers
    }
}
impl Add<UnitKilometers> for UnitKilometers {
    type Output = UnitKilometers;
    #[inline]
    fn add(self, _: UnitKilometers) -> Self::Output {
        UnitKilometers
    }
}
impl AddAssign<UnitKilometers> for UnitKilometers {
    #[inline]
    fn add_assign(&mut self, _: UnitKilometers) {}
}
impl Sub<UnitKilometers> for UnitKilometers {
    type Output = UnitKilometers;
    #[inline]
    fn sub(self, _: UnitKilometers) -> Self::Output {
        UnitKilometers
    }
}
impl SubAssign<UnitKilometers> for UnitKilometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilometers) {}
}
pub struct UnitKilometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilometersMul {
    #[inline]
    fn clone(&self) -> UnitKilometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilometersMul {
    #[inline]
    fn eq(&self, other: &UnitKilometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilometersMul> for i8 {
    type Output = Quantity<i8, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for i16 {
    type Output = Quantity<i16, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for i32 {
    type Output = Quantity<i32, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for i64 {
    type Output = Quantity<i64, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for i128 {
    type Output = Quantity<i128, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for isize {
    type Output = Quantity<isize, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for u8 {
    type Output = Quantity<u8, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for u16 {
    type Output = Quantity<u16, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for u32 {
    type Output = Quantity<u32, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for u64 {
    type Output = Quantity<u64, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for u128 {
    type Output = Quantity<u128, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for usize {
    type Output = Quantity<usize, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for f32 {
    type Output = Quantity<f32, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
impl Mul<UnitKilometersMul> for f64 {
    type Output = Quantity<f64, UnitKilometers>;
    fn mul(self, _: UnitKilometersMul) -> Self::Output {
        Quantity::new(self, UnitKilometers)
    }
}
pub struct UnitHectometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectometers {
    #[inline]
    fn clone(&self) -> UnitHectometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectometers {
    #[inline]
    fn eq(&self, other: &UnitHectometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectometers {
    fn default() -> Self {
        UnitHectometers
    }
}
impl Add<UnitHectometers> for UnitHectometers {
    type Output = UnitHectometers;
    #[inline]
    fn add(self, _: UnitHectometers) -> Self::Output {
        UnitHectometers
    }
}
impl AddAssign<UnitHectometers> for UnitHectometers {
    #[inline]
    fn add_assign(&mut self, _: UnitHectometers) {}
}
impl Sub<UnitHectometers> for UnitHectometers {
    type Output = UnitHectometers;
    #[inline]
    fn sub(self, _: UnitHectometers) -> Self::Output {
        UnitHectometers
    }
}
impl SubAssign<UnitHectometers> for UnitHectometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectometers) {}
}
pub struct UnitHectometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectometersMul {
    #[inline]
    fn clone(&self) -> UnitHectometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectometersMul {
    #[inline]
    fn eq(&self, other: &UnitHectometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectometersMul> for i8 {
    type Output = Quantity<i8, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for i16 {
    type Output = Quantity<i16, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for i32 {
    type Output = Quantity<i32, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for i64 {
    type Output = Quantity<i64, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for i128 {
    type Output = Quantity<i128, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for isize {
    type Output = Quantity<isize, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for u8 {
    type Output = Quantity<u8, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for u16 {
    type Output = Quantity<u16, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for u32 {
    type Output = Quantity<u32, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for u64 {
    type Output = Quantity<u64, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for u128 {
    type Output = Quantity<u128, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for usize {
    type Output = Quantity<usize, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for f32 {
    type Output = Quantity<f32, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
impl Mul<UnitHectometersMul> for f64 {
    type Output = Quantity<f64, UnitHectometers>;
    fn mul(self, _: UnitHectometersMul) -> Self::Output {
        Quantity::new(self, UnitHectometers)
    }
}
pub struct UnitDecameters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecameters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecameters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecameters {
    #[inline]
    fn clone(&self) -> UnitDecameters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecameters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecameters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecameters {
    #[inline]
    fn eq(&self, other: &UnitDecameters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecameters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecameters {
    fn default() -> Self {
        UnitDecameters
    }
}
impl Add<UnitDecameters> for UnitDecameters {
    type Output = UnitDecameters;
    #[inline]
    fn add(self, _: UnitDecameters) -> Self::Output {
        UnitDecameters
    }
}
impl AddAssign<UnitDecameters> for UnitDecameters {
    #[inline]
    fn add_assign(&mut self, _: UnitDecameters) {}
}
impl Sub<UnitDecameters> for UnitDecameters {
    type Output = UnitDecameters;
    #[inline]
    fn sub(self, _: UnitDecameters) -> Self::Output {
        UnitDecameters
    }
}
impl SubAssign<UnitDecameters> for UnitDecameters {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecameters) {}
}
pub struct UnitDecametersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecametersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecametersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecametersMul {
    #[inline]
    fn clone(&self) -> UnitDecametersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecametersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecametersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecametersMul {
    #[inline]
    fn eq(&self, other: &UnitDecametersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecametersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecametersMul> for i8 {
    type Output = Quantity<i8, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for i16 {
    type Output = Quantity<i16, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for i32 {
    type Output = Quantity<i32, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for i64 {
    type Output = Quantity<i64, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for i128 {
    type Output = Quantity<i128, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for isize {
    type Output = Quantity<isize, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for u8 {
    type Output = Quantity<u8, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for u16 {
    type Output = Quantity<u16, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for u32 {
    type Output = Quantity<u32, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for u64 {
    type Output = Quantity<u64, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for u128 {
    type Output = Quantity<u128, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for usize {
    type Output = Quantity<usize, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for f32 {
    type Output = Quantity<f32, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
impl Mul<UnitDecametersMul> for f64 {
    type Output = Quantity<f64, UnitDecameters>;
    fn mul(self, _: UnitDecametersMul) -> Self::Output {
        Quantity::new(self, UnitDecameters)
    }
}
pub struct UnitDecimeters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecimeters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecimeters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecimeters {
    #[inline]
    fn clone(&self) -> UnitDecimeters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecimeters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecimeters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecimeters {
    #[inline]
    fn eq(&self, other: &UnitDecimeters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecimeters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecimeters {
    fn default() -> Self {
        UnitDecimeters
    }
}
impl Add<UnitDecimeters> for UnitDecimeters {
    type Output = UnitDecimeters;
    #[inline]
    fn add(self, _: UnitDecimeters) -> Self::Output {
        UnitDecimeters
    }
}
impl AddAssign<UnitDecimeters> for UnitDecimeters {
    #[inline]
    fn add_assign(&mut self, _: UnitDecimeters) {}
}
impl Sub<UnitDecimeters> for UnitDecimeters {
    type Output = UnitDecimeters;
    #[inline]
    fn sub(self, _: UnitDecimeters) -> Self::Output {
        UnitDecimeters
    }
}
impl SubAssign<UnitDecimeters> for UnitDecimeters {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecimeters) {}
}
pub struct UnitDecimetersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecimetersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecimetersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecimetersMul {
    #[inline]
    fn clone(&self) -> UnitDecimetersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecimetersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecimetersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecimetersMul {
    #[inline]
    fn eq(&self, other: &UnitDecimetersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecimetersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecimetersMul> for i8 {
    type Output = Quantity<i8, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for i16 {
    type Output = Quantity<i16, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for i32 {
    type Output = Quantity<i32, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for i64 {
    type Output = Quantity<i64, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for i128 {
    type Output = Quantity<i128, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for isize {
    type Output = Quantity<isize, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for u8 {
    type Output = Quantity<u8, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for u16 {
    type Output = Quantity<u16, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for u32 {
    type Output = Quantity<u32, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for u64 {
    type Output = Quantity<u64, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for u128 {
    type Output = Quantity<u128, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for usize {
    type Output = Quantity<usize, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for f32 {
    type Output = Quantity<f32, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
impl Mul<UnitDecimetersMul> for f64 {
    type Output = Quantity<f64, UnitDecimeters>;
    fn mul(self, _: UnitDecimetersMul) -> Self::Output {
        Quantity::new(self, UnitDecimeters)
    }
}
pub struct UnitCentimeters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentimeters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentimeters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentimeters {
    #[inline]
    fn clone(&self) -> UnitCentimeters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentimeters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentimeters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentimeters {
    #[inline]
    fn eq(&self, other: &UnitCentimeters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentimeters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentimeters {
    fn default() -> Self {
        UnitCentimeters
    }
}
impl Add<UnitCentimeters> for UnitCentimeters {
    type Output = UnitCentimeters;
    #[inline]
    fn add(self, _: UnitCentimeters) -> Self::Output {
        UnitCentimeters
    }
}
impl AddAssign<UnitCentimeters> for UnitCentimeters {
    #[inline]
    fn add_assign(&mut self, _: UnitCentimeters) {}
}
impl Sub<UnitCentimeters> for UnitCentimeters {
    type Output = UnitCentimeters;
    #[inline]
    fn sub(self, _: UnitCentimeters) -> Self::Output {
        UnitCentimeters
    }
}
impl SubAssign<UnitCentimeters> for UnitCentimeters {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentimeters) {}
}
pub struct UnitCentimetersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentimetersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentimetersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentimetersMul {
    #[inline]
    fn clone(&self) -> UnitCentimetersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentimetersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentimetersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentimetersMul {
    #[inline]
    fn eq(&self, other: &UnitCentimetersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentimetersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentimetersMul> for i8 {
    type Output = Quantity<i8, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for i16 {
    type Output = Quantity<i16, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for i32 {
    type Output = Quantity<i32, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for i64 {
    type Output = Quantity<i64, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for i128 {
    type Output = Quantity<i128, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for isize {
    type Output = Quantity<isize, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for u8 {
    type Output = Quantity<u8, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for u16 {
    type Output = Quantity<u16, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for u32 {
    type Output = Quantity<u32, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for u64 {
    type Output = Quantity<u64, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for u128 {
    type Output = Quantity<u128, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for usize {
    type Output = Quantity<usize, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for f32 {
    type Output = Quantity<f32, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
impl Mul<UnitCentimetersMul> for f64 {
    type Output = Quantity<f64, UnitCentimeters>;
    fn mul(self, _: UnitCentimetersMul) -> Self::Output {
        Quantity::new(self, UnitCentimeters)
    }
}
pub struct UnitMillimeters;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillimeters {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillimeters")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillimeters {
    #[inline]
    fn clone(&self) -> UnitMillimeters {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillimeters {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillimeters {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillimeters {
    #[inline]
    fn eq(&self, other: &UnitMillimeters) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillimeters {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillimeters {
    fn default() -> Self {
        UnitMillimeters
    }
}
impl Add<UnitMillimeters> for UnitMillimeters {
    type Output = UnitMillimeters;
    #[inline]
    fn add(self, _: UnitMillimeters) -> Self::Output {
        UnitMillimeters
    }
}
impl AddAssign<UnitMillimeters> for UnitMillimeters {
    #[inline]
    fn add_assign(&mut self, _: UnitMillimeters) {}
}
impl Sub<UnitMillimeters> for UnitMillimeters {
    type Output = UnitMillimeters;
    #[inline]
    fn sub(self, _: UnitMillimeters) -> Self::Output {
        UnitMillimeters
    }
}
impl SubAssign<UnitMillimeters> for UnitMillimeters {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillimeters) {}
}
pub struct UnitMillimetersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillimetersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillimetersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillimetersMul {
    #[inline]
    fn clone(&self) -> UnitMillimetersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillimetersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillimetersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillimetersMul {
    #[inline]
    fn eq(&self, other: &UnitMillimetersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillimetersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillimetersMul> for i8 {
    type Output = Quantity<i8, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for i16 {
    type Output = Quantity<i16, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for i32 {
    type Output = Quantity<i32, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for i64 {
    type Output = Quantity<i64, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for i128 {
    type Output = Quantity<i128, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for isize {
    type Output = Quantity<isize, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for u8 {
    type Output = Quantity<u8, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for u16 {
    type Output = Quantity<u16, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for u32 {
    type Output = Quantity<u32, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for u64 {
    type Output = Quantity<u64, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for u128 {
    type Output = Quantity<u128, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for usize {
    type Output = Quantity<usize, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for f32 {
    type Output = Quantity<f32, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
impl Mul<UnitMillimetersMul> for f64 {
    type Output = Quantity<f64, UnitMillimeters>;
    fn mul(self, _: UnitMillimetersMul) -> Self::Output {
        Quantity::new(self, UnitMillimeters)
    }
}
pub struct UnitMicrometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrometers {
    #[inline]
    fn clone(&self) -> UnitMicrometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrometers {
    #[inline]
    fn eq(&self, other: &UnitMicrometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrometers {
    fn default() -> Self {
        UnitMicrometers
    }
}
impl Add<UnitMicrometers> for UnitMicrometers {
    type Output = UnitMicrometers;
    #[inline]
    fn add(self, _: UnitMicrometers) -> Self::Output {
        UnitMicrometers
    }
}
impl AddAssign<UnitMicrometers> for UnitMicrometers {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrometers) {}
}
impl Sub<UnitMicrometers> for UnitMicrometers {
    type Output = UnitMicrometers;
    #[inline]
    fn sub(self, _: UnitMicrometers) -> Self::Output {
        UnitMicrometers
    }
}
impl SubAssign<UnitMicrometers> for UnitMicrometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrometers) {}
}
pub struct UnitMicrometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrometersMul {
    #[inline]
    fn clone(&self) -> UnitMicrometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrometersMul {
    #[inline]
    fn eq(&self, other: &UnitMicrometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrometersMul> for i8 {
    type Output = Quantity<i8, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for i16 {
    type Output = Quantity<i16, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for i32 {
    type Output = Quantity<i32, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for i64 {
    type Output = Quantity<i64, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for i128 {
    type Output = Quantity<i128, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for isize {
    type Output = Quantity<isize, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for u8 {
    type Output = Quantity<u8, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for u16 {
    type Output = Quantity<u16, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for u32 {
    type Output = Quantity<u32, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for u64 {
    type Output = Quantity<u64, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for u128 {
    type Output = Quantity<u128, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for usize {
    type Output = Quantity<usize, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for f32 {
    type Output = Quantity<f32, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
impl Mul<UnitMicrometersMul> for f64 {
    type Output = Quantity<f64, UnitMicrometers>;
    fn mul(self, _: UnitMicrometersMul) -> Self::Output {
        Quantity::new(self, UnitMicrometers)
    }
}
pub struct UnitNanometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanometers {
    #[inline]
    fn clone(&self) -> UnitNanometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanometers {
    #[inline]
    fn eq(&self, other: &UnitNanometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanometers {
    fn default() -> Self {
        UnitNanometers
    }
}
impl Add<UnitNanometers> for UnitNanometers {
    type Output = UnitNanometers;
    #[inline]
    fn add(self, _: UnitNanometers) -> Self::Output {
        UnitNanometers
    }
}
impl AddAssign<UnitNanometers> for UnitNanometers {
    #[inline]
    fn add_assign(&mut self, _: UnitNanometers) {}
}
impl Sub<UnitNanometers> for UnitNanometers {
    type Output = UnitNanometers;
    #[inline]
    fn sub(self, _: UnitNanometers) -> Self::Output {
        UnitNanometers
    }
}
impl SubAssign<UnitNanometers> for UnitNanometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanometers) {}
}
pub struct UnitNanometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanometersMul {
    #[inline]
    fn clone(&self) -> UnitNanometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanometersMul {
    #[inline]
    fn eq(&self, other: &UnitNanometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanometersMul> for i8 {
    type Output = Quantity<i8, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for i16 {
    type Output = Quantity<i16, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for i32 {
    type Output = Quantity<i32, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for i64 {
    type Output = Quantity<i64, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for i128 {
    type Output = Quantity<i128, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for isize {
    type Output = Quantity<isize, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for u8 {
    type Output = Quantity<u8, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for u16 {
    type Output = Quantity<u16, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for u32 {
    type Output = Quantity<u32, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for u64 {
    type Output = Quantity<u64, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for u128 {
    type Output = Quantity<u128, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for usize {
    type Output = Quantity<usize, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for f32 {
    type Output = Quantity<f32, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
impl Mul<UnitNanometersMul> for f64 {
    type Output = Quantity<f64, UnitNanometers>;
    fn mul(self, _: UnitNanometersMul) -> Self::Output {
        Quantity::new(self, UnitNanometers)
    }
}
pub struct UnitPicometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicometers {
    #[inline]
    fn clone(&self) -> UnitPicometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicometers {
    #[inline]
    fn eq(&self, other: &UnitPicometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicometers {
    fn default() -> Self {
        UnitPicometers
    }
}
impl Add<UnitPicometers> for UnitPicometers {
    type Output = UnitPicometers;
    #[inline]
    fn add(self, _: UnitPicometers) -> Self::Output {
        UnitPicometers
    }
}
impl AddAssign<UnitPicometers> for UnitPicometers {
    #[inline]
    fn add_assign(&mut self, _: UnitPicometers) {}
}
impl Sub<UnitPicometers> for UnitPicometers {
    type Output = UnitPicometers;
    #[inline]
    fn sub(self, _: UnitPicometers) -> Self::Output {
        UnitPicometers
    }
}
impl SubAssign<UnitPicometers> for UnitPicometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicometers) {}
}
pub struct UnitPicometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicometersMul {
    #[inline]
    fn clone(&self) -> UnitPicometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicometersMul {
    #[inline]
    fn eq(&self, other: &UnitPicometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicometersMul> for i8 {
    type Output = Quantity<i8, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for i16 {
    type Output = Quantity<i16, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for i32 {
    type Output = Quantity<i32, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for i64 {
    type Output = Quantity<i64, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for i128 {
    type Output = Quantity<i128, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for isize {
    type Output = Quantity<isize, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for u8 {
    type Output = Quantity<u8, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for u16 {
    type Output = Quantity<u16, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for u32 {
    type Output = Quantity<u32, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for u64 {
    type Output = Quantity<u64, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for u128 {
    type Output = Quantity<u128, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for usize {
    type Output = Quantity<usize, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for f32 {
    type Output = Quantity<f32, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
impl Mul<UnitPicometersMul> for f64 {
    type Output = Quantity<f64, UnitPicometers>;
    fn mul(self, _: UnitPicometersMul) -> Self::Output {
        Quantity::new(self, UnitPicometers)
    }
}
pub struct UnitFemtometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtometers {
    #[inline]
    fn clone(&self) -> UnitFemtometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtometers {
    #[inline]
    fn eq(&self, other: &UnitFemtometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtometers {
    fn default() -> Self {
        UnitFemtometers
    }
}
impl Add<UnitFemtometers> for UnitFemtometers {
    type Output = UnitFemtometers;
    #[inline]
    fn add(self, _: UnitFemtometers) -> Self::Output {
        UnitFemtometers
    }
}
impl AddAssign<UnitFemtometers> for UnitFemtometers {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtometers) {}
}
impl Sub<UnitFemtometers> for UnitFemtometers {
    type Output = UnitFemtometers;
    #[inline]
    fn sub(self, _: UnitFemtometers) -> Self::Output {
        UnitFemtometers
    }
}
impl SubAssign<UnitFemtometers> for UnitFemtometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtometers) {}
}
pub struct UnitFemtometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtometersMul {
    #[inline]
    fn clone(&self) -> UnitFemtometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtometersMul {
    #[inline]
    fn eq(&self, other: &UnitFemtometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtometersMul> for i8 {
    type Output = Quantity<i8, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for i16 {
    type Output = Quantity<i16, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for i32 {
    type Output = Quantity<i32, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for i64 {
    type Output = Quantity<i64, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for i128 {
    type Output = Quantity<i128, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for isize {
    type Output = Quantity<isize, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for u8 {
    type Output = Quantity<u8, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for u16 {
    type Output = Quantity<u16, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for u32 {
    type Output = Quantity<u32, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for u64 {
    type Output = Quantity<u64, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for u128 {
    type Output = Quantity<u128, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for usize {
    type Output = Quantity<usize, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for f32 {
    type Output = Quantity<f32, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
impl Mul<UnitFemtometersMul> for f64 {
    type Output = Quantity<f64, UnitFemtometers>;
    fn mul(self, _: UnitFemtometersMul) -> Self::Output {
        Quantity::new(self, UnitFemtometers)
    }
}
pub struct UnitAttometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttometers {
    #[inline]
    fn clone(&self) -> UnitAttometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttometers {
    #[inline]
    fn eq(&self, other: &UnitAttometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttometers {
    fn default() -> Self {
        UnitAttometers
    }
}
impl Add<UnitAttometers> for UnitAttometers {
    type Output = UnitAttometers;
    #[inline]
    fn add(self, _: UnitAttometers) -> Self::Output {
        UnitAttometers
    }
}
impl AddAssign<UnitAttometers> for UnitAttometers {
    #[inline]
    fn add_assign(&mut self, _: UnitAttometers) {}
}
impl Sub<UnitAttometers> for UnitAttometers {
    type Output = UnitAttometers;
    #[inline]
    fn sub(self, _: UnitAttometers) -> Self::Output {
        UnitAttometers
    }
}
impl SubAssign<UnitAttometers> for UnitAttometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttometers) {}
}
pub struct UnitAttometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttometersMul {
    #[inline]
    fn clone(&self) -> UnitAttometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttometersMul {
    #[inline]
    fn eq(&self, other: &UnitAttometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttometersMul> for i8 {
    type Output = Quantity<i8, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for i16 {
    type Output = Quantity<i16, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for i32 {
    type Output = Quantity<i32, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for i64 {
    type Output = Quantity<i64, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for i128 {
    type Output = Quantity<i128, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for isize {
    type Output = Quantity<isize, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for u8 {
    type Output = Quantity<u8, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for u16 {
    type Output = Quantity<u16, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for u32 {
    type Output = Quantity<u32, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for u64 {
    type Output = Quantity<u64, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for u128 {
    type Output = Quantity<u128, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for usize {
    type Output = Quantity<usize, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for f32 {
    type Output = Quantity<f32, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
impl Mul<UnitAttometersMul> for f64 {
    type Output = Quantity<f64, UnitAttometers>;
    fn mul(self, _: UnitAttometersMul) -> Self::Output {
        Quantity::new(self, UnitAttometers)
    }
}
pub struct UnitZeptometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptometers {
    #[inline]
    fn clone(&self) -> UnitZeptometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptometers {
    #[inline]
    fn eq(&self, other: &UnitZeptometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptometers {
    fn default() -> Self {
        UnitZeptometers
    }
}
impl Add<UnitZeptometers> for UnitZeptometers {
    type Output = UnitZeptometers;
    #[inline]
    fn add(self, _: UnitZeptometers) -> Self::Output {
        UnitZeptometers
    }
}
impl AddAssign<UnitZeptometers> for UnitZeptometers {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptometers) {}
}
impl Sub<UnitZeptometers> for UnitZeptometers {
    type Output = UnitZeptometers;
    #[inline]
    fn sub(self, _: UnitZeptometers) -> Self::Output {
        UnitZeptometers
    }
}
impl SubAssign<UnitZeptometers> for UnitZeptometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptometers) {}
}
pub struct UnitZeptometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptometersMul {
    #[inline]
    fn clone(&self) -> UnitZeptometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptometersMul {
    #[inline]
    fn eq(&self, other: &UnitZeptometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptometersMul> for i8 {
    type Output = Quantity<i8, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for i16 {
    type Output = Quantity<i16, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for i32 {
    type Output = Quantity<i32, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for i64 {
    type Output = Quantity<i64, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for i128 {
    type Output = Quantity<i128, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for isize {
    type Output = Quantity<isize, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for u8 {
    type Output = Quantity<u8, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for u16 {
    type Output = Quantity<u16, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for u32 {
    type Output = Quantity<u32, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for u64 {
    type Output = Quantity<u64, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for u128 {
    type Output = Quantity<u128, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for usize {
    type Output = Quantity<usize, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for f32 {
    type Output = Quantity<f32, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
impl Mul<UnitZeptometersMul> for f64 {
    type Output = Quantity<f64, UnitZeptometers>;
    fn mul(self, _: UnitZeptometersMul) -> Self::Output {
        Quantity::new(self, UnitZeptometers)
    }
}
pub struct UnitYoctometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctometers {
    #[inline]
    fn clone(&self) -> UnitYoctometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctometers {
    #[inline]
    fn eq(&self, other: &UnitYoctometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctometers {
    fn default() -> Self {
        UnitYoctometers
    }
}
impl Add<UnitYoctometers> for UnitYoctometers {
    type Output = UnitYoctometers;
    #[inline]
    fn add(self, _: UnitYoctometers) -> Self::Output {
        UnitYoctometers
    }
}
impl AddAssign<UnitYoctometers> for UnitYoctometers {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctometers) {}
}
impl Sub<UnitYoctometers> for UnitYoctometers {
    type Output = UnitYoctometers;
    #[inline]
    fn sub(self, _: UnitYoctometers) -> Self::Output {
        UnitYoctometers
    }
}
impl SubAssign<UnitYoctometers> for UnitYoctometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctometers) {}
}
pub struct UnitYoctometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctometersMul {
    #[inline]
    fn clone(&self) -> UnitYoctometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctometersMul {
    #[inline]
    fn eq(&self, other: &UnitYoctometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctometersMul> for i8 {
    type Output = Quantity<i8, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for i16 {
    type Output = Quantity<i16, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for i32 {
    type Output = Quantity<i32, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for i64 {
    type Output = Quantity<i64, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for i128 {
    type Output = Quantity<i128, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for isize {
    type Output = Quantity<isize, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for u8 {
    type Output = Quantity<u8, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for u16 {
    type Output = Quantity<u16, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for u32 {
    type Output = Quantity<u32, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for u64 {
    type Output = Quantity<u64, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for u128 {
    type Output = Quantity<u128, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for usize {
    type Output = Quantity<usize, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for f32 {
    type Output = Quantity<f32, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
impl Mul<UnitYoctometersMul> for f64 {
    type Output = Quantity<f64, UnitYoctometers>;
    fn mul(self, _: UnitYoctometersMul) -> Self::Output {
        Quantity::new(self, UnitYoctometers)
    }
}
pub struct UnitRontometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontometers {
    #[inline]
    fn clone(&self) -> UnitRontometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontometers {
    #[inline]
    fn eq(&self, other: &UnitRontometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontometers {
    fn default() -> Self {
        UnitRontometers
    }
}
impl Add<UnitRontometers> for UnitRontometers {
    type Output = UnitRontometers;
    #[inline]
    fn add(self, _: UnitRontometers) -> Self::Output {
        UnitRontometers
    }
}
impl AddAssign<UnitRontometers> for UnitRontometers {
    #[inline]
    fn add_assign(&mut self, _: UnitRontometers) {}
}
impl Sub<UnitRontometers> for UnitRontometers {
    type Output = UnitRontometers;
    #[inline]
    fn sub(self, _: UnitRontometers) -> Self::Output {
        UnitRontometers
    }
}
impl SubAssign<UnitRontometers> for UnitRontometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontometers) {}
}
pub struct UnitRontometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontometersMul {
    #[inline]
    fn clone(&self) -> UnitRontometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontometersMul {
    #[inline]
    fn eq(&self, other: &UnitRontometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontometersMul> for i8 {
    type Output = Quantity<i8, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for i16 {
    type Output = Quantity<i16, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for i32 {
    type Output = Quantity<i32, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for i64 {
    type Output = Quantity<i64, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for i128 {
    type Output = Quantity<i128, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for isize {
    type Output = Quantity<isize, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for u8 {
    type Output = Quantity<u8, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for u16 {
    type Output = Quantity<u16, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for u32 {
    type Output = Quantity<u32, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for u64 {
    type Output = Quantity<u64, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for u128 {
    type Output = Quantity<u128, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for usize {
    type Output = Quantity<usize, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for f32 {
    type Output = Quantity<f32, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
impl Mul<UnitRontometersMul> for f64 {
    type Output = Quantity<f64, UnitRontometers>;
    fn mul(self, _: UnitRontometersMul) -> Self::Output {
        Quantity::new(self, UnitRontometers)
    }
}
pub struct UnitQuectometers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectometers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectometers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectometers {
    #[inline]
    fn clone(&self) -> UnitQuectometers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectometers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectometers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectometers {
    #[inline]
    fn eq(&self, other: &UnitQuectometers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectometers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectometers {
    fn default() -> Self {
        UnitQuectometers
    }
}
impl Add<UnitQuectometers> for UnitQuectometers {
    type Output = UnitQuectometers;
    #[inline]
    fn add(self, _: UnitQuectometers) -> Self::Output {
        UnitQuectometers
    }
}
impl AddAssign<UnitQuectometers> for UnitQuectometers {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectometers) {}
}
impl Sub<UnitQuectometers> for UnitQuectometers {
    type Output = UnitQuectometers;
    #[inline]
    fn sub(self, _: UnitQuectometers) -> Self::Output {
        UnitQuectometers
    }
}
impl SubAssign<UnitQuectometers> for UnitQuectometers {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectometers) {}
}
pub struct UnitQuectometersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectometersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectometersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectometersMul {
    #[inline]
    fn clone(&self) -> UnitQuectometersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectometersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectometersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectometersMul {
    #[inline]
    fn eq(&self, other: &UnitQuectometersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectometersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectometersMul> for i8 {
    type Output = Quantity<i8, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for i16 {
    type Output = Quantity<i16, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for i32 {
    type Output = Quantity<i32, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for i64 {
    type Output = Quantity<i64, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for i128 {
    type Output = Quantity<i128, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for isize {
    type Output = Quantity<isize, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for u8 {
    type Output = Quantity<u8, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for u16 {
    type Output = Quantity<u16, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for u32 {
    type Output = Quantity<u32, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for u64 {
    type Output = Quantity<u64, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for u128 {
    type Output = Quantity<u128, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for usize {
    type Output = Quantity<usize, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for f32 {
    type Output = Quantity<f32, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
impl Mul<UnitQuectometersMul> for f64 {
    type Output = Quantity<f64, UnitQuectometers>;
    fn mul(self, _: UnitQuectometersMul) -> Self::Output {
        Quantity::new(self, UnitQuectometers)
    }
}
pub type Meters<T> = Quantity<T, UnitMeters>;
#[allow(non_upper_case_globals)]
pub static Meters: UnitMetersMul = UnitMetersMul;
pub type Quettameters<T> = Quantity<T, UnitQuettameters>;
#[allow(non_upper_case_globals)]
pub static Quettameters: UnitQuettametersMul = UnitQuettametersMul;
pub type Ronnameters<T> = Quantity<T, UnitRonnameters>;
#[allow(non_upper_case_globals)]
pub static Ronnameters: UnitRonnametersMul = UnitRonnametersMul;
pub type Yottameters<T> = Quantity<T, UnitYottameters>;
#[allow(non_upper_case_globals)]
pub static Yottameters: UnitYottametersMul = UnitYottametersMul;
pub type Zettameters<T> = Quantity<T, UnitZettameters>;
#[allow(non_upper_case_globals)]
pub static Zettameters: UnitZettametersMul = UnitZettametersMul;
pub type Exameters<T> = Quantity<T, UnitExameters>;
#[allow(non_upper_case_globals)]
pub static Exameters: UnitExametersMul = UnitExametersMul;
pub type Petameters<T> = Quantity<T, UnitPetameters>;
#[allow(non_upper_case_globals)]
pub static Petameters: UnitPetametersMul = UnitPetametersMul;
pub type Terameters<T> = Quantity<T, UnitTerameters>;
#[allow(non_upper_case_globals)]
pub static Terameters: UnitTerametersMul = UnitTerametersMul;
pub type Gigameters<T> = Quantity<T, UnitGigameters>;
#[allow(non_upper_case_globals)]
pub static Gigameters: UnitGigametersMul = UnitGigametersMul;
pub type Megameters<T> = Quantity<T, UnitMegameters>;
#[allow(non_upper_case_globals)]
pub static Megameters: UnitMegametersMul = UnitMegametersMul;
pub type Kilometers<T> = Quantity<T, UnitKilometers>;
#[allow(non_upper_case_globals)]
pub static Kilometers: UnitKilometersMul = UnitKilometersMul;
pub type Hectometers<T> = Quantity<T, UnitHectometers>;
#[allow(non_upper_case_globals)]
pub static Hectometers: UnitHectometersMul = UnitHectometersMul;
pub type Decameters<T> = Quantity<T, UnitDecameters>;
#[allow(non_upper_case_globals)]
pub static Decameters: UnitDecametersMul = UnitDecametersMul;
pub type Decimeters<T> = Quantity<T, UnitDecimeters>;
#[allow(non_upper_case_globals)]
pub static Decimeters: UnitDecimetersMul = UnitDecimetersMul;
pub type Centimeters<T> = Quantity<T, UnitCentimeters>;
#[allow(non_upper_case_globals)]
pub static Centimeters: UnitCentimetersMul = UnitCentimetersMul;
pub type Millimeters<T> = Quantity<T, UnitMillimeters>;
#[allow(non_upper_case_globals)]
pub static Millimeters: UnitMillimetersMul = UnitMillimetersMul;
pub type Micrometers<T> = Quantity<T, UnitMicrometers>;
#[allow(non_upper_case_globals)]
pub static Micrometers: UnitMicrometersMul = UnitMicrometersMul;
pub type Nanometers<T> = Quantity<T, UnitNanometers>;
#[allow(non_upper_case_globals)]
pub static Nanometers: UnitNanometersMul = UnitNanometersMul;
pub type Picometers<T> = Quantity<T, UnitPicometers>;
#[allow(non_upper_case_globals)]
pub static Picometers: UnitPicometersMul = UnitPicometersMul;
pub type Femtometers<T> = Quantity<T, UnitFemtometers>;
#[allow(non_upper_case_globals)]
pub static Femtometers: UnitFemtometersMul = UnitFemtometersMul;
pub type Attometers<T> = Quantity<T, UnitAttometers>;
#[allow(non_upper_case_globals)]
pub static Attometers: UnitAttometersMul = UnitAttometersMul;
pub type Zeptometers<T> = Quantity<T, UnitZeptometers>;
#[allow(non_upper_case_globals)]
pub static Zeptometers: UnitZeptometersMul = UnitZeptometersMul;
pub type Yoctometers<T> = Quantity<T, UnitYoctometers>;
#[allow(non_upper_case_globals)]
pub static Yoctometers: UnitYoctometersMul = UnitYoctometersMul;
pub type Rontometers<T> = Quantity<T, UnitRontometers>;
#[allow(non_upper_case_globals)]
pub static Rontometers: UnitRontometersMul = UnitRontometersMul;
pub type Quectometers<T> = Quantity<T, UnitQuectometers>;
#[allow(non_upper_case_globals)]
pub static Quectometers: UnitQuectometersMul = UnitQuectometersMul;
pub struct UnitGrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGrams {
    #[inline]
    fn clone(&self) -> UnitGrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGrams {
    #[inline]
    fn eq(&self, other: &UnitGrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGrams {
    fn default() -> Self {
        UnitGrams
    }
}
impl Add<UnitGrams> for UnitGrams {
    type Output = UnitGrams;
    #[inline]
    fn add(self, _: UnitGrams) -> Self::Output {
        UnitGrams
    }
}
impl AddAssign<UnitGrams> for UnitGrams {
    #[inline]
    fn add_assign(&mut self, _: UnitGrams) {}
}
impl Sub<UnitGrams> for UnitGrams {
    type Output = UnitGrams;
    #[inline]
    fn sub(self, _: UnitGrams) -> Self::Output {
        UnitGrams
    }
}
impl SubAssign<UnitGrams> for UnitGrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitGrams) {}
}
pub struct UnitGramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGramsMul {
    #[inline]
    fn clone(&self) -> UnitGramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGramsMul {
    #[inline]
    fn eq(&self, other: &UnitGramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGramsMul> for i8 {
    type Output = Quantity<i8, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for i16 {
    type Output = Quantity<i16, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for i32 {
    type Output = Quantity<i32, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for i64 {
    type Output = Quantity<i64, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for i128 {
    type Output = Quantity<i128, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for isize {
    type Output = Quantity<isize, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for u8 {
    type Output = Quantity<u8, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for u16 {
    type Output = Quantity<u16, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for u32 {
    type Output = Quantity<u32, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for u64 {
    type Output = Quantity<u64, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for u128 {
    type Output = Quantity<u128, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for usize {
    type Output = Quantity<usize, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for f32 {
    type Output = Quantity<f32, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
impl Mul<UnitGramsMul> for f64 {
    type Output = Quantity<f64, UnitGrams>;
    fn mul(self, _: UnitGramsMul) -> Self::Output {
        Quantity::new(self, UnitGrams)
    }
}
pub struct UnitQuettagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagrams {
    #[inline]
    fn clone(&self) -> UnitQuettagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagrams {
    #[inline]
    fn eq(&self, other: &UnitQuettagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettagrams {
    fn default() -> Self {
        UnitQuettagrams
    }
}
impl Add<UnitQuettagrams> for UnitQuettagrams {
    type Output = UnitQuettagrams;
    #[inline]
    fn add(self, _: UnitQuettagrams) -> Self::Output {
        UnitQuettagrams
    }
}
impl AddAssign<UnitQuettagrams> for UnitQuettagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettagrams) {}
}
impl Sub<UnitQuettagrams> for UnitQuettagrams {
    type Output = UnitQuettagrams;
    #[inline]
    fn sub(self, _: UnitQuettagrams) -> Self::Output {
        UnitQuettagrams
    }
}
impl SubAssign<UnitQuettagrams> for UnitQuettagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettagrams) {}
}
pub struct UnitQuettagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagramsMul {
    #[inline]
    fn clone(&self) -> UnitQuettagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagramsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettagramsMul> for i8 {
    type Output = Quantity<i8, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for i16 {
    type Output = Quantity<i16, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for i32 {
    type Output = Quantity<i32, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for i64 {
    type Output = Quantity<i64, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for i128 {
    type Output = Quantity<i128, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for isize {
    type Output = Quantity<isize, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for u8 {
    type Output = Quantity<u8, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for u16 {
    type Output = Quantity<u16, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for u32 {
    type Output = Quantity<u32, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for u64 {
    type Output = Quantity<u64, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for u128 {
    type Output = Quantity<u128, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for usize {
    type Output = Quantity<usize, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for f32 {
    type Output = Quantity<f32, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
impl Mul<UnitQuettagramsMul> for f64 {
    type Output = Quantity<f64, UnitQuettagrams>;
    fn mul(self, _: UnitQuettagramsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrams)
    }
}
pub struct UnitRonnagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagrams {
    #[inline]
    fn clone(&self) -> UnitRonnagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagrams {
    #[inline]
    fn eq(&self, other: &UnitRonnagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnagrams {
    fn default() -> Self {
        UnitRonnagrams
    }
}
impl Add<UnitRonnagrams> for UnitRonnagrams {
    type Output = UnitRonnagrams;
    #[inline]
    fn add(self, _: UnitRonnagrams) -> Self::Output {
        UnitRonnagrams
    }
}
impl AddAssign<UnitRonnagrams> for UnitRonnagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnagrams) {}
}
impl Sub<UnitRonnagrams> for UnitRonnagrams {
    type Output = UnitRonnagrams;
    #[inline]
    fn sub(self, _: UnitRonnagrams) -> Self::Output {
        UnitRonnagrams
    }
}
impl SubAssign<UnitRonnagrams> for UnitRonnagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnagrams) {}
}
pub struct UnitRonnagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagramsMul {
    #[inline]
    fn clone(&self) -> UnitRonnagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagramsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnagramsMul> for i8 {
    type Output = Quantity<i8, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for i16 {
    type Output = Quantity<i16, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for i32 {
    type Output = Quantity<i32, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for i64 {
    type Output = Quantity<i64, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for i128 {
    type Output = Quantity<i128, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for isize {
    type Output = Quantity<isize, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for u8 {
    type Output = Quantity<u8, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for u16 {
    type Output = Quantity<u16, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for u32 {
    type Output = Quantity<u32, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for u64 {
    type Output = Quantity<u64, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for u128 {
    type Output = Quantity<u128, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for usize {
    type Output = Quantity<usize, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for f32 {
    type Output = Quantity<f32, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
impl Mul<UnitRonnagramsMul> for f64 {
    type Output = Quantity<f64, UnitRonnagrams>;
    fn mul(self, _: UnitRonnagramsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrams)
    }
}
pub struct UnitYottagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagrams {
    #[inline]
    fn clone(&self) -> UnitYottagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagrams {
    #[inline]
    fn eq(&self, other: &UnitYottagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottagrams {
    fn default() -> Self {
        UnitYottagrams
    }
}
impl Add<UnitYottagrams> for UnitYottagrams {
    type Output = UnitYottagrams;
    #[inline]
    fn add(self, _: UnitYottagrams) -> Self::Output {
        UnitYottagrams
    }
}
impl AddAssign<UnitYottagrams> for UnitYottagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitYottagrams) {}
}
impl Sub<UnitYottagrams> for UnitYottagrams {
    type Output = UnitYottagrams;
    #[inline]
    fn sub(self, _: UnitYottagrams) -> Self::Output {
        UnitYottagrams
    }
}
impl SubAssign<UnitYottagrams> for UnitYottagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottagrams) {}
}
pub struct UnitYottagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagramsMul {
    #[inline]
    fn clone(&self) -> UnitYottagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagramsMul {
    #[inline]
    fn eq(&self, other: &UnitYottagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottagramsMul> for i8 {
    type Output = Quantity<i8, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for i16 {
    type Output = Quantity<i16, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for i32 {
    type Output = Quantity<i32, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for i64 {
    type Output = Quantity<i64, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for i128 {
    type Output = Quantity<i128, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for isize {
    type Output = Quantity<isize, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for u8 {
    type Output = Quantity<u8, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for u16 {
    type Output = Quantity<u16, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for u32 {
    type Output = Quantity<u32, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for u64 {
    type Output = Quantity<u64, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for u128 {
    type Output = Quantity<u128, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for usize {
    type Output = Quantity<usize, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for f32 {
    type Output = Quantity<f32, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
impl Mul<UnitYottagramsMul> for f64 {
    type Output = Quantity<f64, UnitYottagrams>;
    fn mul(self, _: UnitYottagramsMul) -> Self::Output {
        Quantity::new(self, UnitYottagrams)
    }
}
pub struct UnitZettagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagrams {
    #[inline]
    fn clone(&self) -> UnitZettagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagrams {
    #[inline]
    fn eq(&self, other: &UnitZettagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettagrams {
    fn default() -> Self {
        UnitZettagrams
    }
}
impl Add<UnitZettagrams> for UnitZettagrams {
    type Output = UnitZettagrams;
    #[inline]
    fn add(self, _: UnitZettagrams) -> Self::Output {
        UnitZettagrams
    }
}
impl AddAssign<UnitZettagrams> for UnitZettagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitZettagrams) {}
}
impl Sub<UnitZettagrams> for UnitZettagrams {
    type Output = UnitZettagrams;
    #[inline]
    fn sub(self, _: UnitZettagrams) -> Self::Output {
        UnitZettagrams
    }
}
impl SubAssign<UnitZettagrams> for UnitZettagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettagrams) {}
}
pub struct UnitZettagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagramsMul {
    #[inline]
    fn clone(&self) -> UnitZettagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagramsMul {
    #[inline]
    fn eq(&self, other: &UnitZettagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettagramsMul> for i8 {
    type Output = Quantity<i8, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for i16 {
    type Output = Quantity<i16, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for i32 {
    type Output = Quantity<i32, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for i64 {
    type Output = Quantity<i64, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for i128 {
    type Output = Quantity<i128, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for isize {
    type Output = Quantity<isize, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for u8 {
    type Output = Quantity<u8, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for u16 {
    type Output = Quantity<u16, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for u32 {
    type Output = Quantity<u32, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for u64 {
    type Output = Quantity<u64, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for u128 {
    type Output = Quantity<u128, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for usize {
    type Output = Quantity<usize, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for f32 {
    type Output = Quantity<f32, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
impl Mul<UnitZettagramsMul> for f64 {
    type Output = Quantity<f64, UnitZettagrams>;
    fn mul(self, _: UnitZettagramsMul) -> Self::Output {
        Quantity::new(self, UnitZettagrams)
    }
}
pub struct UnitExagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagrams {
    #[inline]
    fn clone(&self) -> UnitExagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagrams {
    #[inline]
    fn eq(&self, other: &UnitExagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExagrams {
    fn default() -> Self {
        UnitExagrams
    }
}
impl Add<UnitExagrams> for UnitExagrams {
    type Output = UnitExagrams;
    #[inline]
    fn add(self, _: UnitExagrams) -> Self::Output {
        UnitExagrams
    }
}
impl AddAssign<UnitExagrams> for UnitExagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitExagrams) {}
}
impl Sub<UnitExagrams> for UnitExagrams {
    type Output = UnitExagrams;
    #[inline]
    fn sub(self, _: UnitExagrams) -> Self::Output {
        UnitExagrams
    }
}
impl SubAssign<UnitExagrams> for UnitExagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitExagrams) {}
}
pub struct UnitExagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagramsMul {
    #[inline]
    fn clone(&self) -> UnitExagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagramsMul {
    #[inline]
    fn eq(&self, other: &UnitExagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExagramsMul> for i8 {
    type Output = Quantity<i8, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for i16 {
    type Output = Quantity<i16, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for i32 {
    type Output = Quantity<i32, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for i64 {
    type Output = Quantity<i64, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for i128 {
    type Output = Quantity<i128, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for isize {
    type Output = Quantity<isize, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for u8 {
    type Output = Quantity<u8, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for u16 {
    type Output = Quantity<u16, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for u32 {
    type Output = Quantity<u32, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for u64 {
    type Output = Quantity<u64, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for u128 {
    type Output = Quantity<u128, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for usize {
    type Output = Quantity<usize, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for f32 {
    type Output = Quantity<f32, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
impl Mul<UnitExagramsMul> for f64 {
    type Output = Quantity<f64, UnitExagrams>;
    fn mul(self, _: UnitExagramsMul) -> Self::Output {
        Quantity::new(self, UnitExagrams)
    }
}
pub struct UnitPetagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagrams {
    #[inline]
    fn clone(&self) -> UnitPetagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagrams {
    #[inline]
    fn eq(&self, other: &UnitPetagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetagrams {
    fn default() -> Self {
        UnitPetagrams
    }
}
impl Add<UnitPetagrams> for UnitPetagrams {
    type Output = UnitPetagrams;
    #[inline]
    fn add(self, _: UnitPetagrams) -> Self::Output {
        UnitPetagrams
    }
}
impl AddAssign<UnitPetagrams> for UnitPetagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitPetagrams) {}
}
impl Sub<UnitPetagrams> for UnitPetagrams {
    type Output = UnitPetagrams;
    #[inline]
    fn sub(self, _: UnitPetagrams) -> Self::Output {
        UnitPetagrams
    }
}
impl SubAssign<UnitPetagrams> for UnitPetagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetagrams) {}
}
pub struct UnitPetagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagramsMul {
    #[inline]
    fn clone(&self) -> UnitPetagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagramsMul {
    #[inline]
    fn eq(&self, other: &UnitPetagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetagramsMul> for i8 {
    type Output = Quantity<i8, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for i16 {
    type Output = Quantity<i16, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for i32 {
    type Output = Quantity<i32, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for i64 {
    type Output = Quantity<i64, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for i128 {
    type Output = Quantity<i128, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for isize {
    type Output = Quantity<isize, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for u8 {
    type Output = Quantity<u8, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for u16 {
    type Output = Quantity<u16, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for u32 {
    type Output = Quantity<u32, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for u64 {
    type Output = Quantity<u64, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for u128 {
    type Output = Quantity<u128, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for usize {
    type Output = Quantity<usize, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for f32 {
    type Output = Quantity<f32, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
impl Mul<UnitPetagramsMul> for f64 {
    type Output = Quantity<f64, UnitPetagrams>;
    fn mul(self, _: UnitPetagramsMul) -> Self::Output {
        Quantity::new(self, UnitPetagrams)
    }
}
pub struct UnitTeragrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragrams {
    #[inline]
    fn clone(&self) -> UnitTeragrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragrams {
    #[inline]
    fn eq(&self, other: &UnitTeragrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeragrams {
    fn default() -> Self {
        UnitTeragrams
    }
}
impl Add<UnitTeragrams> for UnitTeragrams {
    type Output = UnitTeragrams;
    #[inline]
    fn add(self, _: UnitTeragrams) -> Self::Output {
        UnitTeragrams
    }
}
impl AddAssign<UnitTeragrams> for UnitTeragrams {
    #[inline]
    fn add_assign(&mut self, _: UnitTeragrams) {}
}
impl Sub<UnitTeragrams> for UnitTeragrams {
    type Output = UnitTeragrams;
    #[inline]
    fn sub(self, _: UnitTeragrams) -> Self::Output {
        UnitTeragrams
    }
}
impl SubAssign<UnitTeragrams> for UnitTeragrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeragrams) {}
}
pub struct UnitTeragramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragramsMul {
    #[inline]
    fn clone(&self) -> UnitTeragramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragramsMul {
    #[inline]
    fn eq(&self, other: &UnitTeragramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeragramsMul> for i8 {
    type Output = Quantity<i8, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for i16 {
    type Output = Quantity<i16, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for i32 {
    type Output = Quantity<i32, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for i64 {
    type Output = Quantity<i64, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for i128 {
    type Output = Quantity<i128, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for isize {
    type Output = Quantity<isize, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for u8 {
    type Output = Quantity<u8, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for u16 {
    type Output = Quantity<u16, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for u32 {
    type Output = Quantity<u32, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for u64 {
    type Output = Quantity<u64, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for u128 {
    type Output = Quantity<u128, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for usize {
    type Output = Quantity<usize, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for f32 {
    type Output = Quantity<f32, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
impl Mul<UnitTeragramsMul> for f64 {
    type Output = Quantity<f64, UnitTeragrams>;
    fn mul(self, _: UnitTeragramsMul) -> Self::Output {
        Quantity::new(self, UnitTeragrams)
    }
}
pub struct UnitGigagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagrams {
    #[inline]
    fn clone(&self) -> UnitGigagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagrams {
    #[inline]
    fn eq(&self, other: &UnitGigagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigagrams {
    fn default() -> Self {
        UnitGigagrams
    }
}
impl Add<UnitGigagrams> for UnitGigagrams {
    type Output = UnitGigagrams;
    #[inline]
    fn add(self, _: UnitGigagrams) -> Self::Output {
        UnitGigagrams
    }
}
impl AddAssign<UnitGigagrams> for UnitGigagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitGigagrams) {}
}
impl Sub<UnitGigagrams> for UnitGigagrams {
    type Output = UnitGigagrams;
    #[inline]
    fn sub(self, _: UnitGigagrams) -> Self::Output {
        UnitGigagrams
    }
}
impl SubAssign<UnitGigagrams> for UnitGigagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigagrams) {}
}
pub struct UnitGigagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagramsMul {
    #[inline]
    fn clone(&self) -> UnitGigagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagramsMul {
    #[inline]
    fn eq(&self, other: &UnitGigagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigagramsMul> for i8 {
    type Output = Quantity<i8, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for i16 {
    type Output = Quantity<i16, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for i32 {
    type Output = Quantity<i32, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for i64 {
    type Output = Quantity<i64, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for i128 {
    type Output = Quantity<i128, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for isize {
    type Output = Quantity<isize, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for u8 {
    type Output = Quantity<u8, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for u16 {
    type Output = Quantity<u16, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for u32 {
    type Output = Quantity<u32, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for u64 {
    type Output = Quantity<u64, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for u128 {
    type Output = Quantity<u128, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for usize {
    type Output = Quantity<usize, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for f32 {
    type Output = Quantity<f32, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
impl Mul<UnitGigagramsMul> for f64 {
    type Output = Quantity<f64, UnitGigagrams>;
    fn mul(self, _: UnitGigagramsMul) -> Self::Output {
        Quantity::new(self, UnitGigagrams)
    }
}
pub struct UnitMegagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagrams {
    #[inline]
    fn clone(&self) -> UnitMegagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagrams {
    #[inline]
    fn eq(&self, other: &UnitMegagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegagrams {
    fn default() -> Self {
        UnitMegagrams
    }
}
impl Add<UnitMegagrams> for UnitMegagrams {
    type Output = UnitMegagrams;
    #[inline]
    fn add(self, _: UnitMegagrams) -> Self::Output {
        UnitMegagrams
    }
}
impl AddAssign<UnitMegagrams> for UnitMegagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitMegagrams) {}
}
impl Sub<UnitMegagrams> for UnitMegagrams {
    type Output = UnitMegagrams;
    #[inline]
    fn sub(self, _: UnitMegagrams) -> Self::Output {
        UnitMegagrams
    }
}
impl SubAssign<UnitMegagrams> for UnitMegagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegagrams) {}
}
pub struct UnitMegagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagramsMul {
    #[inline]
    fn clone(&self) -> UnitMegagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagramsMul {
    #[inline]
    fn eq(&self, other: &UnitMegagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegagramsMul> for i8 {
    type Output = Quantity<i8, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for i16 {
    type Output = Quantity<i16, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for i32 {
    type Output = Quantity<i32, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for i64 {
    type Output = Quantity<i64, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for i128 {
    type Output = Quantity<i128, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for isize {
    type Output = Quantity<isize, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for u8 {
    type Output = Quantity<u8, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for u16 {
    type Output = Quantity<u16, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for u32 {
    type Output = Quantity<u32, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for u64 {
    type Output = Quantity<u64, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for u128 {
    type Output = Quantity<u128, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for usize {
    type Output = Quantity<usize, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for f32 {
    type Output = Quantity<f32, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
impl Mul<UnitMegagramsMul> for f64 {
    type Output = Quantity<f64, UnitMegagrams>;
    fn mul(self, _: UnitMegagramsMul) -> Self::Output {
        Quantity::new(self, UnitMegagrams)
    }
}
pub struct UnitKilograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilograms {
    #[inline]
    fn clone(&self) -> UnitKilograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilograms {
    #[inline]
    fn eq(&self, other: &UnitKilograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilograms {
    fn default() -> Self {
        UnitKilograms
    }
}
impl Add<UnitKilograms> for UnitKilograms {
    type Output = UnitKilograms;
    #[inline]
    fn add(self, _: UnitKilograms) -> Self::Output {
        UnitKilograms
    }
}
impl AddAssign<UnitKilograms> for UnitKilograms {
    #[inline]
    fn add_assign(&mut self, _: UnitKilograms) {}
}
impl Sub<UnitKilograms> for UnitKilograms {
    type Output = UnitKilograms;
    #[inline]
    fn sub(self, _: UnitKilograms) -> Self::Output {
        UnitKilograms
    }
}
impl SubAssign<UnitKilograms> for UnitKilograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilograms) {}
}
pub struct UnitKilogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilogramsMul {
    #[inline]
    fn clone(&self) -> UnitKilogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilogramsMul {
    #[inline]
    fn eq(&self, other: &UnitKilogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilogramsMul> for i8 {
    type Output = Quantity<i8, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for i16 {
    type Output = Quantity<i16, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for i32 {
    type Output = Quantity<i32, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for i64 {
    type Output = Quantity<i64, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for i128 {
    type Output = Quantity<i128, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for isize {
    type Output = Quantity<isize, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for u8 {
    type Output = Quantity<u8, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for u16 {
    type Output = Quantity<u16, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for u32 {
    type Output = Quantity<u32, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for u64 {
    type Output = Quantity<u64, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for u128 {
    type Output = Quantity<u128, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for usize {
    type Output = Quantity<usize, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for f32 {
    type Output = Quantity<f32, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
impl Mul<UnitKilogramsMul> for f64 {
    type Output = Quantity<f64, UnitKilograms>;
    fn mul(self, _: UnitKilogramsMul) -> Self::Output {
        Quantity::new(self, UnitKilograms)
    }
}
pub struct UnitHectograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectograms {
    #[inline]
    fn clone(&self) -> UnitHectograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectograms {
    #[inline]
    fn eq(&self, other: &UnitHectograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectograms {
    fn default() -> Self {
        UnitHectograms
    }
}
impl Add<UnitHectograms> for UnitHectograms {
    type Output = UnitHectograms;
    #[inline]
    fn add(self, _: UnitHectograms) -> Self::Output {
        UnitHectograms
    }
}
impl AddAssign<UnitHectograms> for UnitHectograms {
    #[inline]
    fn add_assign(&mut self, _: UnitHectograms) {}
}
impl Sub<UnitHectograms> for UnitHectograms {
    type Output = UnitHectograms;
    #[inline]
    fn sub(self, _: UnitHectograms) -> Self::Output {
        UnitHectograms
    }
}
impl SubAssign<UnitHectograms> for UnitHectograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectograms) {}
}
pub struct UnitHectogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectogramsMul {
    #[inline]
    fn clone(&self) -> UnitHectogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectogramsMul {
    #[inline]
    fn eq(&self, other: &UnitHectogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectogramsMul> for i8 {
    type Output = Quantity<i8, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for i16 {
    type Output = Quantity<i16, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for i32 {
    type Output = Quantity<i32, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for i64 {
    type Output = Quantity<i64, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for i128 {
    type Output = Quantity<i128, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for isize {
    type Output = Quantity<isize, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for u8 {
    type Output = Quantity<u8, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for u16 {
    type Output = Quantity<u16, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for u32 {
    type Output = Quantity<u32, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for u64 {
    type Output = Quantity<u64, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for u128 {
    type Output = Quantity<u128, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for usize {
    type Output = Quantity<usize, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for f32 {
    type Output = Quantity<f32, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
impl Mul<UnitHectogramsMul> for f64 {
    type Output = Quantity<f64, UnitHectograms>;
    fn mul(self, _: UnitHectogramsMul) -> Self::Output {
        Quantity::new(self, UnitHectograms)
    }
}
pub struct UnitDecagrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagrams {
    #[inline]
    fn clone(&self) -> UnitDecagrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagrams {
    #[inline]
    fn eq(&self, other: &UnitDecagrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecagrams {
    fn default() -> Self {
        UnitDecagrams
    }
}
impl Add<UnitDecagrams> for UnitDecagrams {
    type Output = UnitDecagrams;
    #[inline]
    fn add(self, _: UnitDecagrams) -> Self::Output {
        UnitDecagrams
    }
}
impl AddAssign<UnitDecagrams> for UnitDecagrams {
    #[inline]
    fn add_assign(&mut self, _: UnitDecagrams) {}
}
impl Sub<UnitDecagrams> for UnitDecagrams {
    type Output = UnitDecagrams;
    #[inline]
    fn sub(self, _: UnitDecagrams) -> Self::Output {
        UnitDecagrams
    }
}
impl SubAssign<UnitDecagrams> for UnitDecagrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecagrams) {}
}
pub struct UnitDecagramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagramsMul {
    #[inline]
    fn clone(&self) -> UnitDecagramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagramsMul {
    #[inline]
    fn eq(&self, other: &UnitDecagramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecagramsMul> for i8 {
    type Output = Quantity<i8, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for i16 {
    type Output = Quantity<i16, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for i32 {
    type Output = Quantity<i32, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for i64 {
    type Output = Quantity<i64, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for i128 {
    type Output = Quantity<i128, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for isize {
    type Output = Quantity<isize, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for u8 {
    type Output = Quantity<u8, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for u16 {
    type Output = Quantity<u16, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for u32 {
    type Output = Quantity<u32, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for u64 {
    type Output = Quantity<u64, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for u128 {
    type Output = Quantity<u128, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for usize {
    type Output = Quantity<usize, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for f32 {
    type Output = Quantity<f32, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
impl Mul<UnitDecagramsMul> for f64 {
    type Output = Quantity<f64, UnitDecagrams>;
    fn mul(self, _: UnitDecagramsMul) -> Self::Output {
        Quantity::new(self, UnitDecagrams)
    }
}
pub struct UnitDecigrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigrams {
    #[inline]
    fn clone(&self) -> UnitDecigrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigrams {
    #[inline]
    fn eq(&self, other: &UnitDecigrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecigrams {
    fn default() -> Self {
        UnitDecigrams
    }
}
impl Add<UnitDecigrams> for UnitDecigrams {
    type Output = UnitDecigrams;
    #[inline]
    fn add(self, _: UnitDecigrams) -> Self::Output {
        UnitDecigrams
    }
}
impl AddAssign<UnitDecigrams> for UnitDecigrams {
    #[inline]
    fn add_assign(&mut self, _: UnitDecigrams) {}
}
impl Sub<UnitDecigrams> for UnitDecigrams {
    type Output = UnitDecigrams;
    #[inline]
    fn sub(self, _: UnitDecigrams) -> Self::Output {
        UnitDecigrams
    }
}
impl SubAssign<UnitDecigrams> for UnitDecigrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecigrams) {}
}
pub struct UnitDecigramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigramsMul {
    #[inline]
    fn clone(&self) -> UnitDecigramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigramsMul {
    #[inline]
    fn eq(&self, other: &UnitDecigramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecigramsMul> for i8 {
    type Output = Quantity<i8, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for i16 {
    type Output = Quantity<i16, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for i32 {
    type Output = Quantity<i32, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for i64 {
    type Output = Quantity<i64, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for i128 {
    type Output = Quantity<i128, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for isize {
    type Output = Quantity<isize, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for u8 {
    type Output = Quantity<u8, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for u16 {
    type Output = Quantity<u16, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for u32 {
    type Output = Quantity<u32, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for u64 {
    type Output = Quantity<u64, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for u128 {
    type Output = Quantity<u128, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for usize {
    type Output = Quantity<usize, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for f32 {
    type Output = Quantity<f32, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
impl Mul<UnitDecigramsMul> for f64 {
    type Output = Quantity<f64, UnitDecigrams>;
    fn mul(self, _: UnitDecigramsMul) -> Self::Output {
        Quantity::new(self, UnitDecigrams)
    }
}
pub struct UnitCentigrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigrams {
    #[inline]
    fn clone(&self) -> UnitCentigrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigrams {
    #[inline]
    fn eq(&self, other: &UnitCentigrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentigrams {
    fn default() -> Self {
        UnitCentigrams
    }
}
impl Add<UnitCentigrams> for UnitCentigrams {
    type Output = UnitCentigrams;
    #[inline]
    fn add(self, _: UnitCentigrams) -> Self::Output {
        UnitCentigrams
    }
}
impl AddAssign<UnitCentigrams> for UnitCentigrams {
    #[inline]
    fn add_assign(&mut self, _: UnitCentigrams) {}
}
impl Sub<UnitCentigrams> for UnitCentigrams {
    type Output = UnitCentigrams;
    #[inline]
    fn sub(self, _: UnitCentigrams) -> Self::Output {
        UnitCentigrams
    }
}
impl SubAssign<UnitCentigrams> for UnitCentigrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentigrams) {}
}
pub struct UnitCentigramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigramsMul {
    #[inline]
    fn clone(&self) -> UnitCentigramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigramsMul {
    #[inline]
    fn eq(&self, other: &UnitCentigramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentigramsMul> for i8 {
    type Output = Quantity<i8, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for i16 {
    type Output = Quantity<i16, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for i32 {
    type Output = Quantity<i32, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for i64 {
    type Output = Quantity<i64, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for i128 {
    type Output = Quantity<i128, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for isize {
    type Output = Quantity<isize, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for u8 {
    type Output = Quantity<u8, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for u16 {
    type Output = Quantity<u16, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for u32 {
    type Output = Quantity<u32, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for u64 {
    type Output = Quantity<u64, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for u128 {
    type Output = Quantity<u128, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for usize {
    type Output = Quantity<usize, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for f32 {
    type Output = Quantity<f32, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
impl Mul<UnitCentigramsMul> for f64 {
    type Output = Quantity<f64, UnitCentigrams>;
    fn mul(self, _: UnitCentigramsMul) -> Self::Output {
        Quantity::new(self, UnitCentigrams)
    }
}
pub struct UnitMilligrams;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligrams {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligrams")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligrams {
    #[inline]
    fn clone(&self) -> UnitMilligrams {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligrams {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligrams {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligrams {
    #[inline]
    fn eq(&self, other: &UnitMilligrams) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligrams {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilligrams {
    fn default() -> Self {
        UnitMilligrams
    }
}
impl Add<UnitMilligrams> for UnitMilligrams {
    type Output = UnitMilligrams;
    #[inline]
    fn add(self, _: UnitMilligrams) -> Self::Output {
        UnitMilligrams
    }
}
impl AddAssign<UnitMilligrams> for UnitMilligrams {
    #[inline]
    fn add_assign(&mut self, _: UnitMilligrams) {}
}
impl Sub<UnitMilligrams> for UnitMilligrams {
    type Output = UnitMilligrams;
    #[inline]
    fn sub(self, _: UnitMilligrams) -> Self::Output {
        UnitMilligrams
    }
}
impl SubAssign<UnitMilligrams> for UnitMilligrams {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilligrams) {}
}
pub struct UnitMilligramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligramsMul {
    #[inline]
    fn clone(&self) -> UnitMilligramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligramsMul {
    #[inline]
    fn eq(&self, other: &UnitMilligramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilligramsMul> for i8 {
    type Output = Quantity<i8, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for i16 {
    type Output = Quantity<i16, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for i32 {
    type Output = Quantity<i32, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for i64 {
    type Output = Quantity<i64, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for i128 {
    type Output = Quantity<i128, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for isize {
    type Output = Quantity<isize, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for u8 {
    type Output = Quantity<u8, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for u16 {
    type Output = Quantity<u16, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for u32 {
    type Output = Quantity<u32, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for u64 {
    type Output = Quantity<u64, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for u128 {
    type Output = Quantity<u128, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for usize {
    type Output = Quantity<usize, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for f32 {
    type Output = Quantity<f32, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
impl Mul<UnitMilligramsMul> for f64 {
    type Output = Quantity<f64, UnitMilligrams>;
    fn mul(self, _: UnitMilligramsMul) -> Self::Output {
        Quantity::new(self, UnitMilligrams)
    }
}
pub struct UnitMicrograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrograms {
    #[inline]
    fn clone(&self) -> UnitMicrograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrograms {
    #[inline]
    fn eq(&self, other: &UnitMicrograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrograms {
    fn default() -> Self {
        UnitMicrograms
    }
}
impl Add<UnitMicrograms> for UnitMicrograms {
    type Output = UnitMicrograms;
    #[inline]
    fn add(self, _: UnitMicrograms) -> Self::Output {
        UnitMicrograms
    }
}
impl AddAssign<UnitMicrograms> for UnitMicrograms {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrograms) {}
}
impl Sub<UnitMicrograms> for UnitMicrograms {
    type Output = UnitMicrograms;
    #[inline]
    fn sub(self, _: UnitMicrograms) -> Self::Output {
        UnitMicrograms
    }
}
impl SubAssign<UnitMicrograms> for UnitMicrograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrograms) {}
}
pub struct UnitMicrogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrogramsMul {
    #[inline]
    fn clone(&self) -> UnitMicrogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrogramsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrogramsMul> for i8 {
    type Output = Quantity<i8, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for i16 {
    type Output = Quantity<i16, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for i32 {
    type Output = Quantity<i32, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for i64 {
    type Output = Quantity<i64, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for i128 {
    type Output = Quantity<i128, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for isize {
    type Output = Quantity<isize, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for u8 {
    type Output = Quantity<u8, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for u16 {
    type Output = Quantity<u16, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for u32 {
    type Output = Quantity<u32, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for u64 {
    type Output = Quantity<u64, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for u128 {
    type Output = Quantity<u128, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for usize {
    type Output = Quantity<usize, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for f32 {
    type Output = Quantity<f32, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
impl Mul<UnitMicrogramsMul> for f64 {
    type Output = Quantity<f64, UnitMicrograms>;
    fn mul(self, _: UnitMicrogramsMul) -> Self::Output {
        Quantity::new(self, UnitMicrograms)
    }
}
pub struct UnitNanograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanograms {
    #[inline]
    fn clone(&self) -> UnitNanograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanograms {
    #[inline]
    fn eq(&self, other: &UnitNanograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanograms {
    fn default() -> Self {
        UnitNanograms
    }
}
impl Add<UnitNanograms> for UnitNanograms {
    type Output = UnitNanograms;
    #[inline]
    fn add(self, _: UnitNanograms) -> Self::Output {
        UnitNanograms
    }
}
impl AddAssign<UnitNanograms> for UnitNanograms {
    #[inline]
    fn add_assign(&mut self, _: UnitNanograms) {}
}
impl Sub<UnitNanograms> for UnitNanograms {
    type Output = UnitNanograms;
    #[inline]
    fn sub(self, _: UnitNanograms) -> Self::Output {
        UnitNanograms
    }
}
impl SubAssign<UnitNanograms> for UnitNanograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanograms) {}
}
pub struct UnitNanogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanogramsMul {
    #[inline]
    fn clone(&self) -> UnitNanogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanogramsMul {
    #[inline]
    fn eq(&self, other: &UnitNanogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanogramsMul> for i8 {
    type Output = Quantity<i8, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for i16 {
    type Output = Quantity<i16, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for i32 {
    type Output = Quantity<i32, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for i64 {
    type Output = Quantity<i64, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for i128 {
    type Output = Quantity<i128, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for isize {
    type Output = Quantity<isize, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for u8 {
    type Output = Quantity<u8, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for u16 {
    type Output = Quantity<u16, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for u32 {
    type Output = Quantity<u32, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for u64 {
    type Output = Quantity<u64, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for u128 {
    type Output = Quantity<u128, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for usize {
    type Output = Quantity<usize, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for f32 {
    type Output = Quantity<f32, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
impl Mul<UnitNanogramsMul> for f64 {
    type Output = Quantity<f64, UnitNanograms>;
    fn mul(self, _: UnitNanogramsMul) -> Self::Output {
        Quantity::new(self, UnitNanograms)
    }
}
pub struct UnitPicograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicograms {
    #[inline]
    fn clone(&self) -> UnitPicograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicograms {
    #[inline]
    fn eq(&self, other: &UnitPicograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicograms {
    fn default() -> Self {
        UnitPicograms
    }
}
impl Add<UnitPicograms> for UnitPicograms {
    type Output = UnitPicograms;
    #[inline]
    fn add(self, _: UnitPicograms) -> Self::Output {
        UnitPicograms
    }
}
impl AddAssign<UnitPicograms> for UnitPicograms {
    #[inline]
    fn add_assign(&mut self, _: UnitPicograms) {}
}
impl Sub<UnitPicograms> for UnitPicograms {
    type Output = UnitPicograms;
    #[inline]
    fn sub(self, _: UnitPicograms) -> Self::Output {
        UnitPicograms
    }
}
impl SubAssign<UnitPicograms> for UnitPicograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicograms) {}
}
pub struct UnitPicogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicogramsMul {
    #[inline]
    fn clone(&self) -> UnitPicogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicogramsMul {
    #[inline]
    fn eq(&self, other: &UnitPicogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicogramsMul> for i8 {
    type Output = Quantity<i8, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for i16 {
    type Output = Quantity<i16, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for i32 {
    type Output = Quantity<i32, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for i64 {
    type Output = Quantity<i64, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for i128 {
    type Output = Quantity<i128, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for isize {
    type Output = Quantity<isize, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for u8 {
    type Output = Quantity<u8, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for u16 {
    type Output = Quantity<u16, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for u32 {
    type Output = Quantity<u32, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for u64 {
    type Output = Quantity<u64, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for u128 {
    type Output = Quantity<u128, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for usize {
    type Output = Quantity<usize, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for f32 {
    type Output = Quantity<f32, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
impl Mul<UnitPicogramsMul> for f64 {
    type Output = Quantity<f64, UnitPicograms>;
    fn mul(self, _: UnitPicogramsMul) -> Self::Output {
        Quantity::new(self, UnitPicograms)
    }
}
pub struct UnitFemtograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtograms {
    #[inline]
    fn clone(&self) -> UnitFemtograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtograms {
    #[inline]
    fn eq(&self, other: &UnitFemtograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtograms {
    fn default() -> Self {
        UnitFemtograms
    }
}
impl Add<UnitFemtograms> for UnitFemtograms {
    type Output = UnitFemtograms;
    #[inline]
    fn add(self, _: UnitFemtograms) -> Self::Output {
        UnitFemtograms
    }
}
impl AddAssign<UnitFemtograms> for UnitFemtograms {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtograms) {}
}
impl Sub<UnitFemtograms> for UnitFemtograms {
    type Output = UnitFemtograms;
    #[inline]
    fn sub(self, _: UnitFemtograms) -> Self::Output {
        UnitFemtograms
    }
}
impl SubAssign<UnitFemtograms> for UnitFemtograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtograms) {}
}
pub struct UnitFemtogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtogramsMul {
    #[inline]
    fn clone(&self) -> UnitFemtogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtogramsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtogramsMul> for i8 {
    type Output = Quantity<i8, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for i16 {
    type Output = Quantity<i16, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for i32 {
    type Output = Quantity<i32, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for i64 {
    type Output = Quantity<i64, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for i128 {
    type Output = Quantity<i128, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for isize {
    type Output = Quantity<isize, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for u8 {
    type Output = Quantity<u8, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for u16 {
    type Output = Quantity<u16, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for u32 {
    type Output = Quantity<u32, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for u64 {
    type Output = Quantity<u64, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for u128 {
    type Output = Quantity<u128, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for usize {
    type Output = Quantity<usize, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for f32 {
    type Output = Quantity<f32, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
impl Mul<UnitFemtogramsMul> for f64 {
    type Output = Quantity<f64, UnitFemtograms>;
    fn mul(self, _: UnitFemtogramsMul) -> Self::Output {
        Quantity::new(self, UnitFemtograms)
    }
}
pub struct UnitAttograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttograms {
    #[inline]
    fn clone(&self) -> UnitAttograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttograms {
    #[inline]
    fn eq(&self, other: &UnitAttograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttograms {
    fn default() -> Self {
        UnitAttograms
    }
}
impl Add<UnitAttograms> for UnitAttograms {
    type Output = UnitAttograms;
    #[inline]
    fn add(self, _: UnitAttograms) -> Self::Output {
        UnitAttograms
    }
}
impl AddAssign<UnitAttograms> for UnitAttograms {
    #[inline]
    fn add_assign(&mut self, _: UnitAttograms) {}
}
impl Sub<UnitAttograms> for UnitAttograms {
    type Output = UnitAttograms;
    #[inline]
    fn sub(self, _: UnitAttograms) -> Self::Output {
        UnitAttograms
    }
}
impl SubAssign<UnitAttograms> for UnitAttograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttograms) {}
}
pub struct UnitAttogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttogramsMul {
    #[inline]
    fn clone(&self) -> UnitAttogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttogramsMul {
    #[inline]
    fn eq(&self, other: &UnitAttogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttogramsMul> for i8 {
    type Output = Quantity<i8, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for i16 {
    type Output = Quantity<i16, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for i32 {
    type Output = Quantity<i32, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for i64 {
    type Output = Quantity<i64, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for i128 {
    type Output = Quantity<i128, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for isize {
    type Output = Quantity<isize, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for u8 {
    type Output = Quantity<u8, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for u16 {
    type Output = Quantity<u16, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for u32 {
    type Output = Quantity<u32, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for u64 {
    type Output = Quantity<u64, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for u128 {
    type Output = Quantity<u128, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for usize {
    type Output = Quantity<usize, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for f32 {
    type Output = Quantity<f32, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
impl Mul<UnitAttogramsMul> for f64 {
    type Output = Quantity<f64, UnitAttograms>;
    fn mul(self, _: UnitAttogramsMul) -> Self::Output {
        Quantity::new(self, UnitAttograms)
    }
}
pub struct UnitZeptograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptograms {
    #[inline]
    fn clone(&self) -> UnitZeptograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptograms {
    #[inline]
    fn eq(&self, other: &UnitZeptograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptograms {
    fn default() -> Self {
        UnitZeptograms
    }
}
impl Add<UnitZeptograms> for UnitZeptograms {
    type Output = UnitZeptograms;
    #[inline]
    fn add(self, _: UnitZeptograms) -> Self::Output {
        UnitZeptograms
    }
}
impl AddAssign<UnitZeptograms> for UnitZeptograms {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptograms) {}
}
impl Sub<UnitZeptograms> for UnitZeptograms {
    type Output = UnitZeptograms;
    #[inline]
    fn sub(self, _: UnitZeptograms) -> Self::Output {
        UnitZeptograms
    }
}
impl SubAssign<UnitZeptograms> for UnitZeptograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptograms) {}
}
pub struct UnitZeptogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptogramsMul {
    #[inline]
    fn clone(&self) -> UnitZeptogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptogramsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptogramsMul> for i8 {
    type Output = Quantity<i8, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for i16 {
    type Output = Quantity<i16, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for i32 {
    type Output = Quantity<i32, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for i64 {
    type Output = Quantity<i64, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for i128 {
    type Output = Quantity<i128, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for isize {
    type Output = Quantity<isize, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for u8 {
    type Output = Quantity<u8, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for u16 {
    type Output = Quantity<u16, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for u32 {
    type Output = Quantity<u32, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for u64 {
    type Output = Quantity<u64, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for u128 {
    type Output = Quantity<u128, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for usize {
    type Output = Quantity<usize, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for f32 {
    type Output = Quantity<f32, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
impl Mul<UnitZeptogramsMul> for f64 {
    type Output = Quantity<f64, UnitZeptograms>;
    fn mul(self, _: UnitZeptogramsMul) -> Self::Output {
        Quantity::new(self, UnitZeptograms)
    }
}
pub struct UnitYoctograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctograms {
    #[inline]
    fn clone(&self) -> UnitYoctograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctograms {
    #[inline]
    fn eq(&self, other: &UnitYoctograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctograms {
    fn default() -> Self {
        UnitYoctograms
    }
}
impl Add<UnitYoctograms> for UnitYoctograms {
    type Output = UnitYoctograms;
    #[inline]
    fn add(self, _: UnitYoctograms) -> Self::Output {
        UnitYoctograms
    }
}
impl AddAssign<UnitYoctograms> for UnitYoctograms {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctograms) {}
}
impl Sub<UnitYoctograms> for UnitYoctograms {
    type Output = UnitYoctograms;
    #[inline]
    fn sub(self, _: UnitYoctograms) -> Self::Output {
        UnitYoctograms
    }
}
impl SubAssign<UnitYoctograms> for UnitYoctograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctograms) {}
}
pub struct UnitYoctogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctogramsMul {
    #[inline]
    fn clone(&self) -> UnitYoctogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctogramsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctogramsMul> for i8 {
    type Output = Quantity<i8, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for i16 {
    type Output = Quantity<i16, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for i32 {
    type Output = Quantity<i32, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for i64 {
    type Output = Quantity<i64, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for i128 {
    type Output = Quantity<i128, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for isize {
    type Output = Quantity<isize, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for u8 {
    type Output = Quantity<u8, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for u16 {
    type Output = Quantity<u16, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for u32 {
    type Output = Quantity<u32, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for u64 {
    type Output = Quantity<u64, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for u128 {
    type Output = Quantity<u128, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for usize {
    type Output = Quantity<usize, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for f32 {
    type Output = Quantity<f32, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
impl Mul<UnitYoctogramsMul> for f64 {
    type Output = Quantity<f64, UnitYoctograms>;
    fn mul(self, _: UnitYoctogramsMul) -> Self::Output {
        Quantity::new(self, UnitYoctograms)
    }
}
pub struct UnitRontograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontograms {
    #[inline]
    fn clone(&self) -> UnitRontograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontograms {
    #[inline]
    fn eq(&self, other: &UnitRontograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontograms {
    fn default() -> Self {
        UnitRontograms
    }
}
impl Add<UnitRontograms> for UnitRontograms {
    type Output = UnitRontograms;
    #[inline]
    fn add(self, _: UnitRontograms) -> Self::Output {
        UnitRontograms
    }
}
impl AddAssign<UnitRontograms> for UnitRontograms {
    #[inline]
    fn add_assign(&mut self, _: UnitRontograms) {}
}
impl Sub<UnitRontograms> for UnitRontograms {
    type Output = UnitRontograms;
    #[inline]
    fn sub(self, _: UnitRontograms) -> Self::Output {
        UnitRontograms
    }
}
impl SubAssign<UnitRontograms> for UnitRontograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontograms) {}
}
pub struct UnitRontogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontogramsMul {
    #[inline]
    fn clone(&self) -> UnitRontogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontogramsMul {
    #[inline]
    fn eq(&self, other: &UnitRontogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontogramsMul> for i8 {
    type Output = Quantity<i8, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for i16 {
    type Output = Quantity<i16, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for i32 {
    type Output = Quantity<i32, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for i64 {
    type Output = Quantity<i64, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for i128 {
    type Output = Quantity<i128, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for isize {
    type Output = Quantity<isize, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for u8 {
    type Output = Quantity<u8, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for u16 {
    type Output = Quantity<u16, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for u32 {
    type Output = Quantity<u32, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for u64 {
    type Output = Quantity<u64, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for u128 {
    type Output = Quantity<u128, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for usize {
    type Output = Quantity<usize, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for f32 {
    type Output = Quantity<f32, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
impl Mul<UnitRontogramsMul> for f64 {
    type Output = Quantity<f64, UnitRontograms>;
    fn mul(self, _: UnitRontogramsMul) -> Self::Output {
        Quantity::new(self, UnitRontograms)
    }
}
pub struct UnitQuectograms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectograms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectograms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectograms {
    #[inline]
    fn clone(&self) -> UnitQuectograms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectograms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectograms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectograms {
    #[inline]
    fn eq(&self, other: &UnitQuectograms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectograms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectograms {
    fn default() -> Self {
        UnitQuectograms
    }
}
impl Add<UnitQuectograms> for UnitQuectograms {
    type Output = UnitQuectograms;
    #[inline]
    fn add(self, _: UnitQuectograms) -> Self::Output {
        UnitQuectograms
    }
}
impl AddAssign<UnitQuectograms> for UnitQuectograms {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectograms) {}
}
impl Sub<UnitQuectograms> for UnitQuectograms {
    type Output = UnitQuectograms;
    #[inline]
    fn sub(self, _: UnitQuectograms) -> Self::Output {
        UnitQuectograms
    }
}
impl SubAssign<UnitQuectograms> for UnitQuectograms {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectograms) {}
}
pub struct UnitQuectogramsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectogramsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectogramsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectogramsMul {
    #[inline]
    fn clone(&self) -> UnitQuectogramsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectogramsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectogramsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectogramsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectogramsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectogramsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectogramsMul> for i8 {
    type Output = Quantity<i8, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for i16 {
    type Output = Quantity<i16, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for i32 {
    type Output = Quantity<i32, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for i64 {
    type Output = Quantity<i64, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for i128 {
    type Output = Quantity<i128, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for isize {
    type Output = Quantity<isize, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for u8 {
    type Output = Quantity<u8, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for u16 {
    type Output = Quantity<u16, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for u32 {
    type Output = Quantity<u32, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for u64 {
    type Output = Quantity<u64, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for u128 {
    type Output = Quantity<u128, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for usize {
    type Output = Quantity<usize, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for f32 {
    type Output = Quantity<f32, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
impl Mul<UnitQuectogramsMul> for f64 {
    type Output = Quantity<f64, UnitQuectograms>;
    fn mul(self, _: UnitQuectogramsMul) -> Self::Output {
        Quantity::new(self, UnitQuectograms)
    }
}
pub type Grams<T> = Quantity<T, UnitGrams>;
#[allow(non_upper_case_globals)]
pub static Grams: UnitGramsMul = UnitGramsMul;
pub type Quettagrams<T> = Quantity<T, UnitQuettagrams>;
#[allow(non_upper_case_globals)]
pub static Quettagrams: UnitQuettagramsMul = UnitQuettagramsMul;
pub type Ronnagrams<T> = Quantity<T, UnitRonnagrams>;
#[allow(non_upper_case_globals)]
pub static Ronnagrams: UnitRonnagramsMul = UnitRonnagramsMul;
pub type Yottagrams<T> = Quantity<T, UnitYottagrams>;
#[allow(non_upper_case_globals)]
pub static Yottagrams: UnitYottagramsMul = UnitYottagramsMul;
pub type Zettagrams<T> = Quantity<T, UnitZettagrams>;
#[allow(non_upper_case_globals)]
pub static Zettagrams: UnitZettagramsMul = UnitZettagramsMul;
pub type Exagrams<T> = Quantity<T, UnitExagrams>;
#[allow(non_upper_case_globals)]
pub static Exagrams: UnitExagramsMul = UnitExagramsMul;
pub type Petagrams<T> = Quantity<T, UnitPetagrams>;
#[allow(non_upper_case_globals)]
pub static Petagrams: UnitPetagramsMul = UnitPetagramsMul;
pub type Teragrams<T> = Quantity<T, UnitTeragrams>;
#[allow(non_upper_case_globals)]
pub static Teragrams: UnitTeragramsMul = UnitTeragramsMul;
pub type Gigagrams<T> = Quantity<T, UnitGigagrams>;
#[allow(non_upper_case_globals)]
pub static Gigagrams: UnitGigagramsMul = UnitGigagramsMul;
pub type Megagrams<T> = Quantity<T, UnitMegagrams>;
#[allow(non_upper_case_globals)]
pub static Megagrams: UnitMegagramsMul = UnitMegagramsMul;
pub type Kilograms<T> = Quantity<T, UnitKilograms>;
#[allow(non_upper_case_globals)]
pub static Kilograms: UnitKilogramsMul = UnitKilogramsMul;
pub type Hectograms<T> = Quantity<T, UnitHectograms>;
#[allow(non_upper_case_globals)]
pub static Hectograms: UnitHectogramsMul = UnitHectogramsMul;
pub type Decagrams<T> = Quantity<T, UnitDecagrams>;
#[allow(non_upper_case_globals)]
pub static Decagrams: UnitDecagramsMul = UnitDecagramsMul;
pub type Decigrams<T> = Quantity<T, UnitDecigrams>;
#[allow(non_upper_case_globals)]
pub static Decigrams: UnitDecigramsMul = UnitDecigramsMul;
pub type Centigrams<T> = Quantity<T, UnitCentigrams>;
#[allow(non_upper_case_globals)]
pub static Centigrams: UnitCentigramsMul = UnitCentigramsMul;
pub type Milligrams<T> = Quantity<T, UnitMilligrams>;
#[allow(non_upper_case_globals)]
pub static Milligrams: UnitMilligramsMul = UnitMilligramsMul;
pub type Micrograms<T> = Quantity<T, UnitMicrograms>;
#[allow(non_upper_case_globals)]
pub static Micrograms: UnitMicrogramsMul = UnitMicrogramsMul;
pub type Nanograms<T> = Quantity<T, UnitNanograms>;
#[allow(non_upper_case_globals)]
pub static Nanograms: UnitNanogramsMul = UnitNanogramsMul;
pub type Picograms<T> = Quantity<T, UnitPicograms>;
#[allow(non_upper_case_globals)]
pub static Picograms: UnitPicogramsMul = UnitPicogramsMul;
pub type Femtograms<T> = Quantity<T, UnitFemtograms>;
#[allow(non_upper_case_globals)]
pub static Femtograms: UnitFemtogramsMul = UnitFemtogramsMul;
pub type Attograms<T> = Quantity<T, UnitAttograms>;
#[allow(non_upper_case_globals)]
pub static Attograms: UnitAttogramsMul = UnitAttogramsMul;
pub type Zeptograms<T> = Quantity<T, UnitZeptograms>;
#[allow(non_upper_case_globals)]
pub static Zeptograms: UnitZeptogramsMul = UnitZeptogramsMul;
pub type Yoctograms<T> = Quantity<T, UnitYoctograms>;
#[allow(non_upper_case_globals)]
pub static Yoctograms: UnitYoctogramsMul = UnitYoctogramsMul;
pub type Rontograms<T> = Quantity<T, UnitRontograms>;
#[allow(non_upper_case_globals)]
pub static Rontograms: UnitRontogramsMul = UnitRontogramsMul;
pub type Quectograms<T> = Quantity<T, UnitQuectograms>;
#[allow(non_upper_case_globals)]
pub static Quectograms: UnitQuectogramsMul = UnitQuectogramsMul;
pub struct UnitAmperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAmperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAmperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAmperes {
    #[inline]
    fn clone(&self) -> UnitAmperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAmperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAmperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAmperes {
    #[inline]
    fn eq(&self, other: &UnitAmperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAmperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAmperes {
    fn default() -> Self {
        UnitAmperes
    }
}
impl Add<UnitAmperes> for UnitAmperes {
    type Output = UnitAmperes;
    #[inline]
    fn add(self, _: UnitAmperes) -> Self::Output {
        UnitAmperes
    }
}
impl AddAssign<UnitAmperes> for UnitAmperes {
    #[inline]
    fn add_assign(&mut self, _: UnitAmperes) {}
}
impl Sub<UnitAmperes> for UnitAmperes {
    type Output = UnitAmperes;
    #[inline]
    fn sub(self, _: UnitAmperes) -> Self::Output {
        UnitAmperes
    }
}
impl SubAssign<UnitAmperes> for UnitAmperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitAmperes) {}
}
pub struct UnitAmperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAmperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAmperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAmperesMul {
    #[inline]
    fn clone(&self) -> UnitAmperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAmperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAmperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAmperesMul {
    #[inline]
    fn eq(&self, other: &UnitAmperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAmperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAmperesMul> for i8 {
    type Output = Quantity<i8, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for i16 {
    type Output = Quantity<i16, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for i32 {
    type Output = Quantity<i32, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for i64 {
    type Output = Quantity<i64, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for i128 {
    type Output = Quantity<i128, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for isize {
    type Output = Quantity<isize, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for u8 {
    type Output = Quantity<u8, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for u16 {
    type Output = Quantity<u16, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for u32 {
    type Output = Quantity<u32, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for u64 {
    type Output = Quantity<u64, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for u128 {
    type Output = Quantity<u128, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for usize {
    type Output = Quantity<usize, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for f32 {
    type Output = Quantity<f32, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
impl Mul<UnitAmperesMul> for f64 {
    type Output = Quantity<f64, UnitAmperes>;
    fn mul(self, _: UnitAmperesMul) -> Self::Output {
        Quantity::new(self, UnitAmperes)
    }
}
pub struct UnitQuettaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaamperes {
    #[inline]
    fn clone(&self) -> UnitQuettaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaamperes {
    #[inline]
    fn eq(&self, other: &UnitQuettaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaamperes {
    fn default() -> Self {
        UnitQuettaamperes
    }
}
impl Add<UnitQuettaamperes> for UnitQuettaamperes {
    type Output = UnitQuettaamperes;
    #[inline]
    fn add(self, _: UnitQuettaamperes) -> Self::Output {
        UnitQuettaamperes
    }
}
impl AddAssign<UnitQuettaamperes> for UnitQuettaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaamperes) {}
}
impl Sub<UnitQuettaamperes> for UnitQuettaamperes {
    type Output = UnitQuettaamperes;
    #[inline]
    fn sub(self, _: UnitQuettaamperes) -> Self::Output {
        UnitQuettaamperes
    }
}
impl SubAssign<UnitQuettaamperes> for UnitQuettaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaamperes) {}
}
pub struct UnitQuettaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaamperesMul {
    #[inline]
    fn clone(&self) -> UnitQuettaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaamperesMul> for i8 {
    type Output = Quantity<i8, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for i16 {
    type Output = Quantity<i16, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for i32 {
    type Output = Quantity<i32, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for i64 {
    type Output = Quantity<i64, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for i128 {
    type Output = Quantity<i128, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for isize {
    type Output = Quantity<isize, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for u8 {
    type Output = Quantity<u8, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for u16 {
    type Output = Quantity<u16, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for u32 {
    type Output = Quantity<u32, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for u64 {
    type Output = Quantity<u64, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for u128 {
    type Output = Quantity<u128, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for usize {
    type Output = Quantity<usize, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for f32 {
    type Output = Quantity<f32, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
impl Mul<UnitQuettaamperesMul> for f64 {
    type Output = Quantity<f64, UnitQuettaamperes>;
    fn mul(self, _: UnitQuettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuettaamperes)
    }
}
pub struct UnitRonnaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaamperes {
    #[inline]
    fn clone(&self) -> UnitRonnaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaamperes {
    #[inline]
    fn eq(&self, other: &UnitRonnaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaamperes {
    fn default() -> Self {
        UnitRonnaamperes
    }
}
impl Add<UnitRonnaamperes> for UnitRonnaamperes {
    type Output = UnitRonnaamperes;
    #[inline]
    fn add(self, _: UnitRonnaamperes) -> Self::Output {
        UnitRonnaamperes
    }
}
impl AddAssign<UnitRonnaamperes> for UnitRonnaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaamperes) {}
}
impl Sub<UnitRonnaamperes> for UnitRonnaamperes {
    type Output = UnitRonnaamperes;
    #[inline]
    fn sub(self, _: UnitRonnaamperes) -> Self::Output {
        UnitRonnaamperes
    }
}
impl SubAssign<UnitRonnaamperes> for UnitRonnaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaamperes) {}
}
pub struct UnitRonnaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaamperesMul {
    #[inline]
    fn clone(&self) -> UnitRonnaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaamperesMul> for i8 {
    type Output = Quantity<i8, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for i16 {
    type Output = Quantity<i16, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for i32 {
    type Output = Quantity<i32, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for i64 {
    type Output = Quantity<i64, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for i128 {
    type Output = Quantity<i128, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for isize {
    type Output = Quantity<isize, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for u8 {
    type Output = Quantity<u8, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for u16 {
    type Output = Quantity<u16, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for u32 {
    type Output = Quantity<u32, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for u64 {
    type Output = Quantity<u64, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for u128 {
    type Output = Quantity<u128, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for usize {
    type Output = Quantity<usize, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for f32 {
    type Output = Quantity<f32, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
impl Mul<UnitRonnaamperesMul> for f64 {
    type Output = Quantity<f64, UnitRonnaamperes>;
    fn mul(self, _: UnitRonnaamperesMul) -> Self::Output {
        Quantity::new(self, UnitRonnaamperes)
    }
}
pub struct UnitYottaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaamperes {
    #[inline]
    fn clone(&self) -> UnitYottaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaamperes {
    #[inline]
    fn eq(&self, other: &UnitYottaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaamperes {
    fn default() -> Self {
        UnitYottaamperes
    }
}
impl Add<UnitYottaamperes> for UnitYottaamperes {
    type Output = UnitYottaamperes;
    #[inline]
    fn add(self, _: UnitYottaamperes) -> Self::Output {
        UnitYottaamperes
    }
}
impl AddAssign<UnitYottaamperes> for UnitYottaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaamperes) {}
}
impl Sub<UnitYottaamperes> for UnitYottaamperes {
    type Output = UnitYottaamperes;
    #[inline]
    fn sub(self, _: UnitYottaamperes) -> Self::Output {
        UnitYottaamperes
    }
}
impl SubAssign<UnitYottaamperes> for UnitYottaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaamperes) {}
}
pub struct UnitYottaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaamperesMul {
    #[inline]
    fn clone(&self) -> UnitYottaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitYottaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaamperesMul> for i8 {
    type Output = Quantity<i8, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for i16 {
    type Output = Quantity<i16, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for i32 {
    type Output = Quantity<i32, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for i64 {
    type Output = Quantity<i64, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for i128 {
    type Output = Quantity<i128, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for isize {
    type Output = Quantity<isize, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for u8 {
    type Output = Quantity<u8, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for u16 {
    type Output = Quantity<u16, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for u32 {
    type Output = Quantity<u32, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for u64 {
    type Output = Quantity<u64, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for u128 {
    type Output = Quantity<u128, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for usize {
    type Output = Quantity<usize, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for f32 {
    type Output = Quantity<f32, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
impl Mul<UnitYottaamperesMul> for f64 {
    type Output = Quantity<f64, UnitYottaamperes>;
    fn mul(self, _: UnitYottaamperesMul) -> Self::Output {
        Quantity::new(self, UnitYottaamperes)
    }
}
pub struct UnitZettaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaamperes {
    #[inline]
    fn clone(&self) -> UnitZettaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaamperes {
    #[inline]
    fn eq(&self, other: &UnitZettaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaamperes {
    fn default() -> Self {
        UnitZettaamperes
    }
}
impl Add<UnitZettaamperes> for UnitZettaamperes {
    type Output = UnitZettaamperes;
    #[inline]
    fn add(self, _: UnitZettaamperes) -> Self::Output {
        UnitZettaamperes
    }
}
impl AddAssign<UnitZettaamperes> for UnitZettaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaamperes) {}
}
impl Sub<UnitZettaamperes> for UnitZettaamperes {
    type Output = UnitZettaamperes;
    #[inline]
    fn sub(self, _: UnitZettaamperes) -> Self::Output {
        UnitZettaamperes
    }
}
impl SubAssign<UnitZettaamperes> for UnitZettaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaamperes) {}
}
pub struct UnitZettaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaamperesMul {
    #[inline]
    fn clone(&self) -> UnitZettaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitZettaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaamperesMul> for i8 {
    type Output = Quantity<i8, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for i16 {
    type Output = Quantity<i16, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for i32 {
    type Output = Quantity<i32, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for i64 {
    type Output = Quantity<i64, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for i128 {
    type Output = Quantity<i128, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for isize {
    type Output = Quantity<isize, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for u8 {
    type Output = Quantity<u8, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for u16 {
    type Output = Quantity<u16, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for u32 {
    type Output = Quantity<u32, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for u64 {
    type Output = Quantity<u64, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for u128 {
    type Output = Quantity<u128, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for usize {
    type Output = Quantity<usize, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for f32 {
    type Output = Quantity<f32, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
impl Mul<UnitZettaamperesMul> for f64 {
    type Output = Quantity<f64, UnitZettaamperes>;
    fn mul(self, _: UnitZettaamperesMul) -> Self::Output {
        Quantity::new(self, UnitZettaamperes)
    }
}
pub struct UnitExaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaamperes {
    #[inline]
    fn clone(&self) -> UnitExaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaamperes {
    #[inline]
    fn eq(&self, other: &UnitExaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaamperes {
    fn default() -> Self {
        UnitExaamperes
    }
}
impl Add<UnitExaamperes> for UnitExaamperes {
    type Output = UnitExaamperes;
    #[inline]
    fn add(self, _: UnitExaamperes) -> Self::Output {
        UnitExaamperes
    }
}
impl AddAssign<UnitExaamperes> for UnitExaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitExaamperes) {}
}
impl Sub<UnitExaamperes> for UnitExaamperes {
    type Output = UnitExaamperes;
    #[inline]
    fn sub(self, _: UnitExaamperes) -> Self::Output {
        UnitExaamperes
    }
}
impl SubAssign<UnitExaamperes> for UnitExaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaamperes) {}
}
pub struct UnitExaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaamperesMul {
    #[inline]
    fn clone(&self) -> UnitExaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitExaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaamperesMul> for i8 {
    type Output = Quantity<i8, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for i16 {
    type Output = Quantity<i16, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for i32 {
    type Output = Quantity<i32, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for i64 {
    type Output = Quantity<i64, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for i128 {
    type Output = Quantity<i128, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for isize {
    type Output = Quantity<isize, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for u8 {
    type Output = Quantity<u8, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for u16 {
    type Output = Quantity<u16, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for u32 {
    type Output = Quantity<u32, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for u64 {
    type Output = Quantity<u64, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for u128 {
    type Output = Quantity<u128, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for usize {
    type Output = Quantity<usize, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for f32 {
    type Output = Quantity<f32, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
impl Mul<UnitExaamperesMul> for f64 {
    type Output = Quantity<f64, UnitExaamperes>;
    fn mul(self, _: UnitExaamperesMul) -> Self::Output {
        Quantity::new(self, UnitExaamperes)
    }
}
pub struct UnitPetaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaamperes {
    #[inline]
    fn clone(&self) -> UnitPetaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaamperes {
    #[inline]
    fn eq(&self, other: &UnitPetaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaamperes {
    fn default() -> Self {
        UnitPetaamperes
    }
}
impl Add<UnitPetaamperes> for UnitPetaamperes {
    type Output = UnitPetaamperes;
    #[inline]
    fn add(self, _: UnitPetaamperes) -> Self::Output {
        UnitPetaamperes
    }
}
impl AddAssign<UnitPetaamperes> for UnitPetaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaamperes) {}
}
impl Sub<UnitPetaamperes> for UnitPetaamperes {
    type Output = UnitPetaamperes;
    #[inline]
    fn sub(self, _: UnitPetaamperes) -> Self::Output {
        UnitPetaamperes
    }
}
impl SubAssign<UnitPetaamperes> for UnitPetaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaamperes) {}
}
pub struct UnitPetaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaamperesMul {
    #[inline]
    fn clone(&self) -> UnitPetaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitPetaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaamperesMul> for i8 {
    type Output = Quantity<i8, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for i16 {
    type Output = Quantity<i16, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for i32 {
    type Output = Quantity<i32, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for i64 {
    type Output = Quantity<i64, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for i128 {
    type Output = Quantity<i128, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for isize {
    type Output = Quantity<isize, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for u8 {
    type Output = Quantity<u8, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for u16 {
    type Output = Quantity<u16, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for u32 {
    type Output = Quantity<u32, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for u64 {
    type Output = Quantity<u64, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for u128 {
    type Output = Quantity<u128, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for usize {
    type Output = Quantity<usize, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for f32 {
    type Output = Quantity<f32, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
impl Mul<UnitPetaamperesMul> for f64 {
    type Output = Quantity<f64, UnitPetaamperes>;
    fn mul(self, _: UnitPetaamperesMul) -> Self::Output {
        Quantity::new(self, UnitPetaamperes)
    }
}
pub struct UnitTeraamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraamperes {
    #[inline]
    fn clone(&self) -> UnitTeraamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraamperes {
    #[inline]
    fn eq(&self, other: &UnitTeraamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraamperes {
    fn default() -> Self {
        UnitTeraamperes
    }
}
impl Add<UnitTeraamperes> for UnitTeraamperes {
    type Output = UnitTeraamperes;
    #[inline]
    fn add(self, _: UnitTeraamperes) -> Self::Output {
        UnitTeraamperes
    }
}
impl AddAssign<UnitTeraamperes> for UnitTeraamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraamperes) {}
}
impl Sub<UnitTeraamperes> for UnitTeraamperes {
    type Output = UnitTeraamperes;
    #[inline]
    fn sub(self, _: UnitTeraamperes) -> Self::Output {
        UnitTeraamperes
    }
}
impl SubAssign<UnitTeraamperes> for UnitTeraamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraamperes) {}
}
pub struct UnitTeraamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraamperesMul {
    #[inline]
    fn clone(&self) -> UnitTeraamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraamperesMul {
    #[inline]
    fn eq(&self, other: &UnitTeraamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraamperesMul> for i8 {
    type Output = Quantity<i8, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for i16 {
    type Output = Quantity<i16, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for i32 {
    type Output = Quantity<i32, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for i64 {
    type Output = Quantity<i64, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for i128 {
    type Output = Quantity<i128, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for isize {
    type Output = Quantity<isize, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for u8 {
    type Output = Quantity<u8, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for u16 {
    type Output = Quantity<u16, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for u32 {
    type Output = Quantity<u32, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for u64 {
    type Output = Quantity<u64, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for u128 {
    type Output = Quantity<u128, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for usize {
    type Output = Quantity<usize, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for f32 {
    type Output = Quantity<f32, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
impl Mul<UnitTeraamperesMul> for f64 {
    type Output = Quantity<f64, UnitTeraamperes>;
    fn mul(self, _: UnitTeraamperesMul) -> Self::Output {
        Quantity::new(self, UnitTeraamperes)
    }
}
pub struct UnitGigaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaamperes {
    #[inline]
    fn clone(&self) -> UnitGigaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaamperes {
    #[inline]
    fn eq(&self, other: &UnitGigaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaamperes {
    fn default() -> Self {
        UnitGigaamperes
    }
}
impl Add<UnitGigaamperes> for UnitGigaamperes {
    type Output = UnitGigaamperes;
    #[inline]
    fn add(self, _: UnitGigaamperes) -> Self::Output {
        UnitGigaamperes
    }
}
impl AddAssign<UnitGigaamperes> for UnitGigaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaamperes) {}
}
impl Sub<UnitGigaamperes> for UnitGigaamperes {
    type Output = UnitGigaamperes;
    #[inline]
    fn sub(self, _: UnitGigaamperes) -> Self::Output {
        UnitGigaamperes
    }
}
impl SubAssign<UnitGigaamperes> for UnitGigaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaamperes) {}
}
pub struct UnitGigaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaamperesMul {
    #[inline]
    fn clone(&self) -> UnitGigaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitGigaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaamperesMul> for i8 {
    type Output = Quantity<i8, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for i16 {
    type Output = Quantity<i16, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for i32 {
    type Output = Quantity<i32, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for i64 {
    type Output = Quantity<i64, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for i128 {
    type Output = Quantity<i128, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for isize {
    type Output = Quantity<isize, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for u8 {
    type Output = Quantity<u8, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for u16 {
    type Output = Quantity<u16, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for u32 {
    type Output = Quantity<u32, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for u64 {
    type Output = Quantity<u64, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for u128 {
    type Output = Quantity<u128, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for usize {
    type Output = Quantity<usize, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for f32 {
    type Output = Quantity<f32, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
impl Mul<UnitGigaamperesMul> for f64 {
    type Output = Quantity<f64, UnitGigaamperes>;
    fn mul(self, _: UnitGigaamperesMul) -> Self::Output {
        Quantity::new(self, UnitGigaamperes)
    }
}
pub struct UnitMegaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaamperes {
    #[inline]
    fn clone(&self) -> UnitMegaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaamperes {
    #[inline]
    fn eq(&self, other: &UnitMegaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaamperes {
    fn default() -> Self {
        UnitMegaamperes
    }
}
impl Add<UnitMegaamperes> for UnitMegaamperes {
    type Output = UnitMegaamperes;
    #[inline]
    fn add(self, _: UnitMegaamperes) -> Self::Output {
        UnitMegaamperes
    }
}
impl AddAssign<UnitMegaamperes> for UnitMegaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaamperes) {}
}
impl Sub<UnitMegaamperes> for UnitMegaamperes {
    type Output = UnitMegaamperes;
    #[inline]
    fn sub(self, _: UnitMegaamperes) -> Self::Output {
        UnitMegaamperes
    }
}
impl SubAssign<UnitMegaamperes> for UnitMegaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaamperes) {}
}
pub struct UnitMegaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaamperesMul {
    #[inline]
    fn clone(&self) -> UnitMegaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitMegaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaamperesMul> for i8 {
    type Output = Quantity<i8, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for i16 {
    type Output = Quantity<i16, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for i32 {
    type Output = Quantity<i32, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for i64 {
    type Output = Quantity<i64, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for i128 {
    type Output = Quantity<i128, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for isize {
    type Output = Quantity<isize, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for u8 {
    type Output = Quantity<u8, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for u16 {
    type Output = Quantity<u16, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for u32 {
    type Output = Quantity<u32, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for u64 {
    type Output = Quantity<u64, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for u128 {
    type Output = Quantity<u128, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for usize {
    type Output = Quantity<usize, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for f32 {
    type Output = Quantity<f32, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
impl Mul<UnitMegaamperesMul> for f64 {
    type Output = Quantity<f64, UnitMegaamperes>;
    fn mul(self, _: UnitMegaamperesMul) -> Self::Output {
        Quantity::new(self, UnitMegaamperes)
    }
}
pub struct UnitKiloamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloamperes {
    #[inline]
    fn clone(&self) -> UnitKiloamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloamperes {
    #[inline]
    fn eq(&self, other: &UnitKiloamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloamperes {
    fn default() -> Self {
        UnitKiloamperes
    }
}
impl Add<UnitKiloamperes> for UnitKiloamperes {
    type Output = UnitKiloamperes;
    #[inline]
    fn add(self, _: UnitKiloamperes) -> Self::Output {
        UnitKiloamperes
    }
}
impl AddAssign<UnitKiloamperes> for UnitKiloamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloamperes) {}
}
impl Sub<UnitKiloamperes> for UnitKiloamperes {
    type Output = UnitKiloamperes;
    #[inline]
    fn sub(self, _: UnitKiloamperes) -> Self::Output {
        UnitKiloamperes
    }
}
impl SubAssign<UnitKiloamperes> for UnitKiloamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloamperes) {}
}
pub struct UnitKiloamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloamperesMul {
    #[inline]
    fn clone(&self) -> UnitKiloamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloamperesMul {
    #[inline]
    fn eq(&self, other: &UnitKiloamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloamperesMul> for i8 {
    type Output = Quantity<i8, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for i16 {
    type Output = Quantity<i16, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for i32 {
    type Output = Quantity<i32, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for i64 {
    type Output = Quantity<i64, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for i128 {
    type Output = Quantity<i128, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for isize {
    type Output = Quantity<isize, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for u8 {
    type Output = Quantity<u8, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for u16 {
    type Output = Quantity<u16, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for u32 {
    type Output = Quantity<u32, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for u64 {
    type Output = Quantity<u64, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for u128 {
    type Output = Quantity<u128, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for usize {
    type Output = Quantity<usize, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for f32 {
    type Output = Quantity<f32, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
impl Mul<UnitKiloamperesMul> for f64 {
    type Output = Quantity<f64, UnitKiloamperes>;
    fn mul(self, _: UnitKiloamperesMul) -> Self::Output {
        Quantity::new(self, UnitKiloamperes)
    }
}
pub struct UnitHectoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoamperes {
    #[inline]
    fn clone(&self) -> UnitHectoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoamperes {
    #[inline]
    fn eq(&self, other: &UnitHectoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoamperes {
    fn default() -> Self {
        UnitHectoamperes
    }
}
impl Add<UnitHectoamperes> for UnitHectoamperes {
    type Output = UnitHectoamperes;
    #[inline]
    fn add(self, _: UnitHectoamperes) -> Self::Output {
        UnitHectoamperes
    }
}
impl AddAssign<UnitHectoamperes> for UnitHectoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoamperes) {}
}
impl Sub<UnitHectoamperes> for UnitHectoamperes {
    type Output = UnitHectoamperes;
    #[inline]
    fn sub(self, _: UnitHectoamperes) -> Self::Output {
        UnitHectoamperes
    }
}
impl SubAssign<UnitHectoamperes> for UnitHectoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoamperes) {}
}
pub struct UnitHectoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoamperesMul {
    #[inline]
    fn clone(&self) -> UnitHectoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitHectoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoamperesMul> for i8 {
    type Output = Quantity<i8, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for i16 {
    type Output = Quantity<i16, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for i32 {
    type Output = Quantity<i32, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for i64 {
    type Output = Quantity<i64, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for i128 {
    type Output = Quantity<i128, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for isize {
    type Output = Quantity<isize, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for u8 {
    type Output = Quantity<u8, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for u16 {
    type Output = Quantity<u16, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for u32 {
    type Output = Quantity<u32, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for u64 {
    type Output = Quantity<u64, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for u128 {
    type Output = Quantity<u128, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for usize {
    type Output = Quantity<usize, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for f32 {
    type Output = Quantity<f32, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
impl Mul<UnitHectoamperesMul> for f64 {
    type Output = Quantity<f64, UnitHectoamperes>;
    fn mul(self, _: UnitHectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitHectoamperes)
    }
}
pub struct UnitDecaamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaamperes {
    #[inline]
    fn clone(&self) -> UnitDecaamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaamperes {
    #[inline]
    fn eq(&self, other: &UnitDecaamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaamperes {
    fn default() -> Self {
        UnitDecaamperes
    }
}
impl Add<UnitDecaamperes> for UnitDecaamperes {
    type Output = UnitDecaamperes;
    #[inline]
    fn add(self, _: UnitDecaamperes) -> Self::Output {
        UnitDecaamperes
    }
}
impl AddAssign<UnitDecaamperes> for UnitDecaamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaamperes) {}
}
impl Sub<UnitDecaamperes> for UnitDecaamperes {
    type Output = UnitDecaamperes;
    #[inline]
    fn sub(self, _: UnitDecaamperes) -> Self::Output {
        UnitDecaamperes
    }
}
impl SubAssign<UnitDecaamperes> for UnitDecaamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaamperes) {}
}
pub struct UnitDecaamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaamperesMul {
    #[inline]
    fn clone(&self) -> UnitDecaamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaamperesMul {
    #[inline]
    fn eq(&self, other: &UnitDecaamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaamperesMul> for i8 {
    type Output = Quantity<i8, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for i16 {
    type Output = Quantity<i16, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for i32 {
    type Output = Quantity<i32, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for i64 {
    type Output = Quantity<i64, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for i128 {
    type Output = Quantity<i128, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for isize {
    type Output = Quantity<isize, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for u8 {
    type Output = Quantity<u8, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for u16 {
    type Output = Quantity<u16, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for u32 {
    type Output = Quantity<u32, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for u64 {
    type Output = Quantity<u64, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for u128 {
    type Output = Quantity<u128, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for usize {
    type Output = Quantity<usize, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for f32 {
    type Output = Quantity<f32, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
impl Mul<UnitDecaamperesMul> for f64 {
    type Output = Quantity<f64, UnitDecaamperes>;
    fn mul(self, _: UnitDecaamperesMul) -> Self::Output {
        Quantity::new(self, UnitDecaamperes)
    }
}
pub struct UnitDeciamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciamperes {
    #[inline]
    fn clone(&self) -> UnitDeciamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciamperes {
    #[inline]
    fn eq(&self, other: &UnitDeciamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciamperes {
    fn default() -> Self {
        UnitDeciamperes
    }
}
impl Add<UnitDeciamperes> for UnitDeciamperes {
    type Output = UnitDeciamperes;
    #[inline]
    fn add(self, _: UnitDeciamperes) -> Self::Output {
        UnitDeciamperes
    }
}
impl AddAssign<UnitDeciamperes> for UnitDeciamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciamperes) {}
}
impl Sub<UnitDeciamperes> for UnitDeciamperes {
    type Output = UnitDeciamperes;
    #[inline]
    fn sub(self, _: UnitDeciamperes) -> Self::Output {
        UnitDeciamperes
    }
}
impl SubAssign<UnitDeciamperes> for UnitDeciamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciamperes) {}
}
pub struct UnitDeciamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciamperesMul {
    #[inline]
    fn clone(&self) -> UnitDeciamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciamperesMul {
    #[inline]
    fn eq(&self, other: &UnitDeciamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciamperesMul> for i8 {
    type Output = Quantity<i8, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for i16 {
    type Output = Quantity<i16, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for i32 {
    type Output = Quantity<i32, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for i64 {
    type Output = Quantity<i64, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for i128 {
    type Output = Quantity<i128, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for isize {
    type Output = Quantity<isize, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for u8 {
    type Output = Quantity<u8, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for u16 {
    type Output = Quantity<u16, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for u32 {
    type Output = Quantity<u32, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for u64 {
    type Output = Quantity<u64, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for u128 {
    type Output = Quantity<u128, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for usize {
    type Output = Quantity<usize, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for f32 {
    type Output = Quantity<f32, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
impl Mul<UnitDeciamperesMul> for f64 {
    type Output = Quantity<f64, UnitDeciamperes>;
    fn mul(self, _: UnitDeciamperesMul) -> Self::Output {
        Quantity::new(self, UnitDeciamperes)
    }
}
pub struct UnitCentiamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiamperes {
    #[inline]
    fn clone(&self) -> UnitCentiamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiamperes {
    #[inline]
    fn eq(&self, other: &UnitCentiamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiamperes {
    fn default() -> Self {
        UnitCentiamperes
    }
}
impl Add<UnitCentiamperes> for UnitCentiamperes {
    type Output = UnitCentiamperes;
    #[inline]
    fn add(self, _: UnitCentiamperes) -> Self::Output {
        UnitCentiamperes
    }
}
impl AddAssign<UnitCentiamperes> for UnitCentiamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiamperes) {}
}
impl Sub<UnitCentiamperes> for UnitCentiamperes {
    type Output = UnitCentiamperes;
    #[inline]
    fn sub(self, _: UnitCentiamperes) -> Self::Output {
        UnitCentiamperes
    }
}
impl SubAssign<UnitCentiamperes> for UnitCentiamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiamperes) {}
}
pub struct UnitCentiamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiamperesMul {
    #[inline]
    fn clone(&self) -> UnitCentiamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiamperesMul {
    #[inline]
    fn eq(&self, other: &UnitCentiamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiamperesMul> for i8 {
    type Output = Quantity<i8, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for i16 {
    type Output = Quantity<i16, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for i32 {
    type Output = Quantity<i32, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for i64 {
    type Output = Quantity<i64, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for i128 {
    type Output = Quantity<i128, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for isize {
    type Output = Quantity<isize, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for u8 {
    type Output = Quantity<u8, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for u16 {
    type Output = Quantity<u16, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for u32 {
    type Output = Quantity<u32, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for u64 {
    type Output = Quantity<u64, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for u128 {
    type Output = Quantity<u128, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for usize {
    type Output = Quantity<usize, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for f32 {
    type Output = Quantity<f32, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
impl Mul<UnitCentiamperesMul> for f64 {
    type Output = Quantity<f64, UnitCentiamperes>;
    fn mul(self, _: UnitCentiamperesMul) -> Self::Output {
        Quantity::new(self, UnitCentiamperes)
    }
}
pub struct UnitMilliamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliamperes {
    #[inline]
    fn clone(&self) -> UnitMilliamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliamperes {
    #[inline]
    fn eq(&self, other: &UnitMilliamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliamperes {
    fn default() -> Self {
        UnitMilliamperes
    }
}
impl Add<UnitMilliamperes> for UnitMilliamperes {
    type Output = UnitMilliamperes;
    #[inline]
    fn add(self, _: UnitMilliamperes) -> Self::Output {
        UnitMilliamperes
    }
}
impl AddAssign<UnitMilliamperes> for UnitMilliamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliamperes) {}
}
impl Sub<UnitMilliamperes> for UnitMilliamperes {
    type Output = UnitMilliamperes;
    #[inline]
    fn sub(self, _: UnitMilliamperes) -> Self::Output {
        UnitMilliamperes
    }
}
impl SubAssign<UnitMilliamperes> for UnitMilliamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliamperes) {}
}
pub struct UnitMilliamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliamperesMul {
    #[inline]
    fn clone(&self) -> UnitMilliamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliamperesMul {
    #[inline]
    fn eq(&self, other: &UnitMilliamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliamperesMul> for i8 {
    type Output = Quantity<i8, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for i16 {
    type Output = Quantity<i16, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for i32 {
    type Output = Quantity<i32, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for i64 {
    type Output = Quantity<i64, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for i128 {
    type Output = Quantity<i128, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for isize {
    type Output = Quantity<isize, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for u8 {
    type Output = Quantity<u8, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for u16 {
    type Output = Quantity<u16, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for u32 {
    type Output = Quantity<u32, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for u64 {
    type Output = Quantity<u64, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for u128 {
    type Output = Quantity<u128, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for usize {
    type Output = Quantity<usize, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for f32 {
    type Output = Quantity<f32, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
impl Mul<UnitMilliamperesMul> for f64 {
    type Output = Quantity<f64, UnitMilliamperes>;
    fn mul(self, _: UnitMilliamperesMul) -> Self::Output {
        Quantity::new(self, UnitMilliamperes)
    }
}
pub struct UnitMicroamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroamperes {
    #[inline]
    fn clone(&self) -> UnitMicroamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroamperes {
    #[inline]
    fn eq(&self, other: &UnitMicroamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroamperes {
    fn default() -> Self {
        UnitMicroamperes
    }
}
impl Add<UnitMicroamperes> for UnitMicroamperes {
    type Output = UnitMicroamperes;
    #[inline]
    fn add(self, _: UnitMicroamperes) -> Self::Output {
        UnitMicroamperes
    }
}
impl AddAssign<UnitMicroamperes> for UnitMicroamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroamperes) {}
}
impl Sub<UnitMicroamperes> for UnitMicroamperes {
    type Output = UnitMicroamperes;
    #[inline]
    fn sub(self, _: UnitMicroamperes) -> Self::Output {
        UnitMicroamperes
    }
}
impl SubAssign<UnitMicroamperes> for UnitMicroamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroamperes) {}
}
pub struct UnitMicroamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroamperesMul {
    #[inline]
    fn clone(&self) -> UnitMicroamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroamperesMul {
    #[inline]
    fn eq(&self, other: &UnitMicroamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroamperesMul> for i8 {
    type Output = Quantity<i8, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for i16 {
    type Output = Quantity<i16, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for i32 {
    type Output = Quantity<i32, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for i64 {
    type Output = Quantity<i64, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for i128 {
    type Output = Quantity<i128, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for isize {
    type Output = Quantity<isize, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for u8 {
    type Output = Quantity<u8, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for u16 {
    type Output = Quantity<u16, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for u32 {
    type Output = Quantity<u32, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for u64 {
    type Output = Quantity<u64, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for u128 {
    type Output = Quantity<u128, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for usize {
    type Output = Quantity<usize, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for f32 {
    type Output = Quantity<f32, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
impl Mul<UnitMicroamperesMul> for f64 {
    type Output = Quantity<f64, UnitMicroamperes>;
    fn mul(self, _: UnitMicroamperesMul) -> Self::Output {
        Quantity::new(self, UnitMicroamperes)
    }
}
pub struct UnitNanoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoamperes {
    #[inline]
    fn clone(&self) -> UnitNanoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoamperes {
    #[inline]
    fn eq(&self, other: &UnitNanoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoamperes {
    fn default() -> Self {
        UnitNanoamperes
    }
}
impl Add<UnitNanoamperes> for UnitNanoamperes {
    type Output = UnitNanoamperes;
    #[inline]
    fn add(self, _: UnitNanoamperes) -> Self::Output {
        UnitNanoamperes
    }
}
impl AddAssign<UnitNanoamperes> for UnitNanoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoamperes) {}
}
impl Sub<UnitNanoamperes> for UnitNanoamperes {
    type Output = UnitNanoamperes;
    #[inline]
    fn sub(self, _: UnitNanoamperes) -> Self::Output {
        UnitNanoamperes
    }
}
impl SubAssign<UnitNanoamperes> for UnitNanoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoamperes) {}
}
pub struct UnitNanoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoamperesMul {
    #[inline]
    fn clone(&self) -> UnitNanoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitNanoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoamperesMul> for i8 {
    type Output = Quantity<i8, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for i16 {
    type Output = Quantity<i16, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for i32 {
    type Output = Quantity<i32, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for i64 {
    type Output = Quantity<i64, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for i128 {
    type Output = Quantity<i128, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for isize {
    type Output = Quantity<isize, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for u8 {
    type Output = Quantity<u8, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for u16 {
    type Output = Quantity<u16, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for u32 {
    type Output = Quantity<u32, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for u64 {
    type Output = Quantity<u64, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for u128 {
    type Output = Quantity<u128, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for usize {
    type Output = Quantity<usize, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for f32 {
    type Output = Quantity<f32, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
impl Mul<UnitNanoamperesMul> for f64 {
    type Output = Quantity<f64, UnitNanoamperes>;
    fn mul(self, _: UnitNanoamperesMul) -> Self::Output {
        Quantity::new(self, UnitNanoamperes)
    }
}
pub struct UnitPicoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoamperes {
    #[inline]
    fn clone(&self) -> UnitPicoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoamperes {
    #[inline]
    fn eq(&self, other: &UnitPicoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoamperes {
    fn default() -> Self {
        UnitPicoamperes
    }
}
impl Add<UnitPicoamperes> for UnitPicoamperes {
    type Output = UnitPicoamperes;
    #[inline]
    fn add(self, _: UnitPicoamperes) -> Self::Output {
        UnitPicoamperes
    }
}
impl AddAssign<UnitPicoamperes> for UnitPicoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoamperes) {}
}
impl Sub<UnitPicoamperes> for UnitPicoamperes {
    type Output = UnitPicoamperes;
    #[inline]
    fn sub(self, _: UnitPicoamperes) -> Self::Output {
        UnitPicoamperes
    }
}
impl SubAssign<UnitPicoamperes> for UnitPicoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoamperes) {}
}
pub struct UnitPicoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoamperesMul {
    #[inline]
    fn clone(&self) -> UnitPicoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitPicoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoamperesMul> for i8 {
    type Output = Quantity<i8, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for i16 {
    type Output = Quantity<i16, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for i32 {
    type Output = Quantity<i32, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for i64 {
    type Output = Quantity<i64, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for i128 {
    type Output = Quantity<i128, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for isize {
    type Output = Quantity<isize, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for u8 {
    type Output = Quantity<u8, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for u16 {
    type Output = Quantity<u16, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for u32 {
    type Output = Quantity<u32, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for u64 {
    type Output = Quantity<u64, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for u128 {
    type Output = Quantity<u128, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for usize {
    type Output = Quantity<usize, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for f32 {
    type Output = Quantity<f32, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
impl Mul<UnitPicoamperesMul> for f64 {
    type Output = Quantity<f64, UnitPicoamperes>;
    fn mul(self, _: UnitPicoamperesMul) -> Self::Output {
        Quantity::new(self, UnitPicoamperes)
    }
}
pub struct UnitFemtoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoamperes {
    #[inline]
    fn clone(&self) -> UnitFemtoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoamperes {
    #[inline]
    fn eq(&self, other: &UnitFemtoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoamperes {
    fn default() -> Self {
        UnitFemtoamperes
    }
}
impl Add<UnitFemtoamperes> for UnitFemtoamperes {
    type Output = UnitFemtoamperes;
    #[inline]
    fn add(self, _: UnitFemtoamperes) -> Self::Output {
        UnitFemtoamperes
    }
}
impl AddAssign<UnitFemtoamperes> for UnitFemtoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoamperes) {}
}
impl Sub<UnitFemtoamperes> for UnitFemtoamperes {
    type Output = UnitFemtoamperes;
    #[inline]
    fn sub(self, _: UnitFemtoamperes) -> Self::Output {
        UnitFemtoamperes
    }
}
impl SubAssign<UnitFemtoamperes> for UnitFemtoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoamperes) {}
}
pub struct UnitFemtoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoamperesMul {
    #[inline]
    fn clone(&self) -> UnitFemtoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoamperesMul> for i8 {
    type Output = Quantity<i8, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for i16 {
    type Output = Quantity<i16, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for i32 {
    type Output = Quantity<i32, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for i64 {
    type Output = Quantity<i64, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for i128 {
    type Output = Quantity<i128, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for isize {
    type Output = Quantity<isize, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for u8 {
    type Output = Quantity<u8, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for u16 {
    type Output = Quantity<u16, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for u32 {
    type Output = Quantity<u32, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for u64 {
    type Output = Quantity<u64, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for u128 {
    type Output = Quantity<u128, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for usize {
    type Output = Quantity<usize, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for f32 {
    type Output = Quantity<f32, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
impl Mul<UnitFemtoamperesMul> for f64 {
    type Output = Quantity<f64, UnitFemtoamperes>;
    fn mul(self, _: UnitFemtoamperesMul) -> Self::Output {
        Quantity::new(self, UnitFemtoamperes)
    }
}
pub struct UnitAttoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoamperes {
    #[inline]
    fn clone(&self) -> UnitAttoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoamperes {
    #[inline]
    fn eq(&self, other: &UnitAttoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoamperes {
    fn default() -> Self {
        UnitAttoamperes
    }
}
impl Add<UnitAttoamperes> for UnitAttoamperes {
    type Output = UnitAttoamperes;
    #[inline]
    fn add(self, _: UnitAttoamperes) -> Self::Output {
        UnitAttoamperes
    }
}
impl AddAssign<UnitAttoamperes> for UnitAttoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoamperes) {}
}
impl Sub<UnitAttoamperes> for UnitAttoamperes {
    type Output = UnitAttoamperes;
    #[inline]
    fn sub(self, _: UnitAttoamperes) -> Self::Output {
        UnitAttoamperes
    }
}
impl SubAssign<UnitAttoamperes> for UnitAttoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoamperes) {}
}
pub struct UnitAttoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoamperesMul {
    #[inline]
    fn clone(&self) -> UnitAttoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitAttoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoamperesMul> for i8 {
    type Output = Quantity<i8, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for i16 {
    type Output = Quantity<i16, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for i32 {
    type Output = Quantity<i32, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for i64 {
    type Output = Quantity<i64, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for i128 {
    type Output = Quantity<i128, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for isize {
    type Output = Quantity<isize, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for u8 {
    type Output = Quantity<u8, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for u16 {
    type Output = Quantity<u16, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for u32 {
    type Output = Quantity<u32, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for u64 {
    type Output = Quantity<u64, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for u128 {
    type Output = Quantity<u128, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for usize {
    type Output = Quantity<usize, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for f32 {
    type Output = Quantity<f32, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
impl Mul<UnitAttoamperesMul> for f64 {
    type Output = Quantity<f64, UnitAttoamperes>;
    fn mul(self, _: UnitAttoamperesMul) -> Self::Output {
        Quantity::new(self, UnitAttoamperes)
    }
}
pub struct UnitZeptoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoamperes {
    #[inline]
    fn clone(&self) -> UnitZeptoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoamperes {
    #[inline]
    fn eq(&self, other: &UnitZeptoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoamperes {
    fn default() -> Self {
        UnitZeptoamperes
    }
}
impl Add<UnitZeptoamperes> for UnitZeptoamperes {
    type Output = UnitZeptoamperes;
    #[inline]
    fn add(self, _: UnitZeptoamperes) -> Self::Output {
        UnitZeptoamperes
    }
}
impl AddAssign<UnitZeptoamperes> for UnitZeptoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoamperes) {}
}
impl Sub<UnitZeptoamperes> for UnitZeptoamperes {
    type Output = UnitZeptoamperes;
    #[inline]
    fn sub(self, _: UnitZeptoamperes) -> Self::Output {
        UnitZeptoamperes
    }
}
impl SubAssign<UnitZeptoamperes> for UnitZeptoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoamperes) {}
}
pub struct UnitZeptoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoamperesMul {
    #[inline]
    fn clone(&self) -> UnitZeptoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoamperesMul> for i8 {
    type Output = Quantity<i8, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for i16 {
    type Output = Quantity<i16, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for i32 {
    type Output = Quantity<i32, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for i64 {
    type Output = Quantity<i64, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for i128 {
    type Output = Quantity<i128, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for isize {
    type Output = Quantity<isize, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for u8 {
    type Output = Quantity<u8, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for u16 {
    type Output = Quantity<u16, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for u32 {
    type Output = Quantity<u32, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for u64 {
    type Output = Quantity<u64, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for u128 {
    type Output = Quantity<u128, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for usize {
    type Output = Quantity<usize, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for f32 {
    type Output = Quantity<f32, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
impl Mul<UnitZeptoamperesMul> for f64 {
    type Output = Quantity<f64, UnitZeptoamperes>;
    fn mul(self, _: UnitZeptoamperesMul) -> Self::Output {
        Quantity::new(self, UnitZeptoamperes)
    }
}
pub struct UnitYoctoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoamperes {
    #[inline]
    fn clone(&self) -> UnitYoctoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoamperes {
    #[inline]
    fn eq(&self, other: &UnitYoctoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoamperes {
    fn default() -> Self {
        UnitYoctoamperes
    }
}
impl Add<UnitYoctoamperes> for UnitYoctoamperes {
    type Output = UnitYoctoamperes;
    #[inline]
    fn add(self, _: UnitYoctoamperes) -> Self::Output {
        UnitYoctoamperes
    }
}
impl AddAssign<UnitYoctoamperes> for UnitYoctoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoamperes) {}
}
impl Sub<UnitYoctoamperes> for UnitYoctoamperes {
    type Output = UnitYoctoamperes;
    #[inline]
    fn sub(self, _: UnitYoctoamperes) -> Self::Output {
        UnitYoctoamperes
    }
}
impl SubAssign<UnitYoctoamperes> for UnitYoctoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoamperes) {}
}
pub struct UnitYoctoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoamperesMul {
    #[inline]
    fn clone(&self) -> UnitYoctoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoamperesMul> for i8 {
    type Output = Quantity<i8, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for i16 {
    type Output = Quantity<i16, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for i32 {
    type Output = Quantity<i32, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for i64 {
    type Output = Quantity<i64, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for i128 {
    type Output = Quantity<i128, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for isize {
    type Output = Quantity<isize, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for u8 {
    type Output = Quantity<u8, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for u16 {
    type Output = Quantity<u16, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for u32 {
    type Output = Quantity<u32, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for u64 {
    type Output = Quantity<u64, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for u128 {
    type Output = Quantity<u128, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for usize {
    type Output = Quantity<usize, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for f32 {
    type Output = Quantity<f32, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
impl Mul<UnitYoctoamperesMul> for f64 {
    type Output = Quantity<f64, UnitYoctoamperes>;
    fn mul(self, _: UnitYoctoamperesMul) -> Self::Output {
        Quantity::new(self, UnitYoctoamperes)
    }
}
pub struct UnitRontoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoamperes {
    #[inline]
    fn clone(&self) -> UnitRontoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoamperes {
    #[inline]
    fn eq(&self, other: &UnitRontoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoamperes {
    fn default() -> Self {
        UnitRontoamperes
    }
}
impl Add<UnitRontoamperes> for UnitRontoamperes {
    type Output = UnitRontoamperes;
    #[inline]
    fn add(self, _: UnitRontoamperes) -> Self::Output {
        UnitRontoamperes
    }
}
impl AddAssign<UnitRontoamperes> for UnitRontoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoamperes) {}
}
impl Sub<UnitRontoamperes> for UnitRontoamperes {
    type Output = UnitRontoamperes;
    #[inline]
    fn sub(self, _: UnitRontoamperes) -> Self::Output {
        UnitRontoamperes
    }
}
impl SubAssign<UnitRontoamperes> for UnitRontoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoamperes) {}
}
pub struct UnitRontoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoamperesMul {
    #[inline]
    fn clone(&self) -> UnitRontoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitRontoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoamperesMul> for i8 {
    type Output = Quantity<i8, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for i16 {
    type Output = Quantity<i16, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for i32 {
    type Output = Quantity<i32, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for i64 {
    type Output = Quantity<i64, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for i128 {
    type Output = Quantity<i128, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for isize {
    type Output = Quantity<isize, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for u8 {
    type Output = Quantity<u8, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for u16 {
    type Output = Quantity<u16, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for u32 {
    type Output = Quantity<u32, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for u64 {
    type Output = Quantity<u64, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for u128 {
    type Output = Quantity<u128, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for usize {
    type Output = Quantity<usize, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for f32 {
    type Output = Quantity<f32, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
impl Mul<UnitRontoamperesMul> for f64 {
    type Output = Quantity<f64, UnitRontoamperes>;
    fn mul(self, _: UnitRontoamperesMul) -> Self::Output {
        Quantity::new(self, UnitRontoamperes)
    }
}
pub struct UnitQuectoamperes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoamperes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoamperes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoamperes {
    #[inline]
    fn clone(&self) -> UnitQuectoamperes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoamperes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoamperes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoamperes {
    #[inline]
    fn eq(&self, other: &UnitQuectoamperes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoamperes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoamperes {
    fn default() -> Self {
        UnitQuectoamperes
    }
}
impl Add<UnitQuectoamperes> for UnitQuectoamperes {
    type Output = UnitQuectoamperes;
    #[inline]
    fn add(self, _: UnitQuectoamperes) -> Self::Output {
        UnitQuectoamperes
    }
}
impl AddAssign<UnitQuectoamperes> for UnitQuectoamperes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoamperes) {}
}
impl Sub<UnitQuectoamperes> for UnitQuectoamperes {
    type Output = UnitQuectoamperes;
    #[inline]
    fn sub(self, _: UnitQuectoamperes) -> Self::Output {
        UnitQuectoamperes
    }
}
impl SubAssign<UnitQuectoamperes> for UnitQuectoamperes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoamperes) {}
}
pub struct UnitQuectoamperesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoamperesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoamperesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoamperesMul {
    #[inline]
    fn clone(&self) -> UnitQuectoamperesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoamperesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoamperesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoamperesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoamperesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoamperesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoamperesMul> for i8 {
    type Output = Quantity<i8, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for i16 {
    type Output = Quantity<i16, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for i32 {
    type Output = Quantity<i32, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for i64 {
    type Output = Quantity<i64, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for i128 {
    type Output = Quantity<i128, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for isize {
    type Output = Quantity<isize, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for u8 {
    type Output = Quantity<u8, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for u16 {
    type Output = Quantity<u16, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for u32 {
    type Output = Quantity<u32, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for u64 {
    type Output = Quantity<u64, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for u128 {
    type Output = Quantity<u128, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for usize {
    type Output = Quantity<usize, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for f32 {
    type Output = Quantity<f32, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
impl Mul<UnitQuectoamperesMul> for f64 {
    type Output = Quantity<f64, UnitQuectoamperes>;
    fn mul(self, _: UnitQuectoamperesMul) -> Self::Output {
        Quantity::new(self, UnitQuectoamperes)
    }
}
pub type Amperes<T> = Quantity<T, UnitAmperes>;
#[allow(non_upper_case_globals)]
pub static Amperes: UnitAmperesMul = UnitAmperesMul;
pub type Quettaamperes<T> = Quantity<T, UnitQuettaamperes>;
#[allow(non_upper_case_globals)]
pub static Quettaamperes: UnitQuettaamperesMul = UnitQuettaamperesMul;
pub type Ronnaamperes<T> = Quantity<T, UnitRonnaamperes>;
#[allow(non_upper_case_globals)]
pub static Ronnaamperes: UnitRonnaamperesMul = UnitRonnaamperesMul;
pub type Yottaamperes<T> = Quantity<T, UnitYottaamperes>;
#[allow(non_upper_case_globals)]
pub static Yottaamperes: UnitYottaamperesMul = UnitYottaamperesMul;
pub type Zettaamperes<T> = Quantity<T, UnitZettaamperes>;
#[allow(non_upper_case_globals)]
pub static Zettaamperes: UnitZettaamperesMul = UnitZettaamperesMul;
pub type Exaamperes<T> = Quantity<T, UnitExaamperes>;
#[allow(non_upper_case_globals)]
pub static Exaamperes: UnitExaamperesMul = UnitExaamperesMul;
pub type Petaamperes<T> = Quantity<T, UnitPetaamperes>;
#[allow(non_upper_case_globals)]
pub static Petaamperes: UnitPetaamperesMul = UnitPetaamperesMul;
pub type Teraamperes<T> = Quantity<T, UnitTeraamperes>;
#[allow(non_upper_case_globals)]
pub static Teraamperes: UnitTeraamperesMul = UnitTeraamperesMul;
pub type Gigaamperes<T> = Quantity<T, UnitGigaamperes>;
#[allow(non_upper_case_globals)]
pub static Gigaamperes: UnitGigaamperesMul = UnitGigaamperesMul;
pub type Megaamperes<T> = Quantity<T, UnitMegaamperes>;
#[allow(non_upper_case_globals)]
pub static Megaamperes: UnitMegaamperesMul = UnitMegaamperesMul;
pub type Kiloamperes<T> = Quantity<T, UnitKiloamperes>;
#[allow(non_upper_case_globals)]
pub static Kiloamperes: UnitKiloamperesMul = UnitKiloamperesMul;
pub type Hectoamperes<T> = Quantity<T, UnitHectoamperes>;
#[allow(non_upper_case_globals)]
pub static Hectoamperes: UnitHectoamperesMul = UnitHectoamperesMul;
pub type Decaamperes<T> = Quantity<T, UnitDecaamperes>;
#[allow(non_upper_case_globals)]
pub static Decaamperes: UnitDecaamperesMul = UnitDecaamperesMul;
pub type Deciamperes<T> = Quantity<T, UnitDeciamperes>;
#[allow(non_upper_case_globals)]
pub static Deciamperes: UnitDeciamperesMul = UnitDeciamperesMul;
pub type Centiamperes<T> = Quantity<T, UnitCentiamperes>;
#[allow(non_upper_case_globals)]
pub static Centiamperes: UnitCentiamperesMul = UnitCentiamperesMul;
pub type Milliamperes<T> = Quantity<T, UnitMilliamperes>;
#[allow(non_upper_case_globals)]
pub static Milliamperes: UnitMilliamperesMul = UnitMilliamperesMul;
pub type Microamperes<T> = Quantity<T, UnitMicroamperes>;
#[allow(non_upper_case_globals)]
pub static Microamperes: UnitMicroamperesMul = UnitMicroamperesMul;
pub type Nanoamperes<T> = Quantity<T, UnitNanoamperes>;
#[allow(non_upper_case_globals)]
pub static Nanoamperes: UnitNanoamperesMul = UnitNanoamperesMul;
pub type Picoamperes<T> = Quantity<T, UnitPicoamperes>;
#[allow(non_upper_case_globals)]
pub static Picoamperes: UnitPicoamperesMul = UnitPicoamperesMul;
pub type Femtoamperes<T> = Quantity<T, UnitFemtoamperes>;
#[allow(non_upper_case_globals)]
pub static Femtoamperes: UnitFemtoamperesMul = UnitFemtoamperesMul;
pub type Attoamperes<T> = Quantity<T, UnitAttoamperes>;
#[allow(non_upper_case_globals)]
pub static Attoamperes: UnitAttoamperesMul = UnitAttoamperesMul;
pub type Zeptoamperes<T> = Quantity<T, UnitZeptoamperes>;
#[allow(non_upper_case_globals)]
pub static Zeptoamperes: UnitZeptoamperesMul = UnitZeptoamperesMul;
pub type Yoctoamperes<T> = Quantity<T, UnitYoctoamperes>;
#[allow(non_upper_case_globals)]
pub static Yoctoamperes: UnitYoctoamperesMul = UnitYoctoamperesMul;
pub type Rontoamperes<T> = Quantity<T, UnitRontoamperes>;
#[allow(non_upper_case_globals)]
pub static Rontoamperes: UnitRontoamperesMul = UnitRontoamperesMul;
pub type Quectoamperes<T> = Quantity<T, UnitQuectoamperes>;
#[allow(non_upper_case_globals)]
pub static Quectoamperes: UnitQuectoamperesMul = UnitQuectoamperesMul;
pub struct UnitKelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKelvin {
    #[inline]
    fn clone(&self) -> UnitKelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKelvin {
    #[inline]
    fn eq(&self, other: &UnitKelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKelvin {
    fn default() -> Self {
        UnitKelvin
    }
}
impl Add<UnitKelvin> for UnitKelvin {
    type Output = UnitKelvin;
    #[inline]
    fn add(self, _: UnitKelvin) -> Self::Output {
        UnitKelvin
    }
}
impl AddAssign<UnitKelvin> for UnitKelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitKelvin) {}
}
impl Sub<UnitKelvin> for UnitKelvin {
    type Output = UnitKelvin;
    #[inline]
    fn sub(self, _: UnitKelvin) -> Self::Output {
        UnitKelvin
    }
}
impl SubAssign<UnitKelvin> for UnitKelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitKelvin) {}
}
pub struct UnitKelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKelvinMul {
    #[inline]
    fn clone(&self) -> UnitKelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKelvinMul {
    #[inline]
    fn eq(&self, other: &UnitKelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKelvinMul> for i8 {
    type Output = Quantity<i8, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for i16 {
    type Output = Quantity<i16, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for i32 {
    type Output = Quantity<i32, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for i64 {
    type Output = Quantity<i64, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for i128 {
    type Output = Quantity<i128, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for isize {
    type Output = Quantity<isize, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for u8 {
    type Output = Quantity<u8, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for u16 {
    type Output = Quantity<u16, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for u32 {
    type Output = Quantity<u32, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for u64 {
    type Output = Quantity<u64, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for u128 {
    type Output = Quantity<u128, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for usize {
    type Output = Quantity<usize, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for f32 {
    type Output = Quantity<f32, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
impl Mul<UnitKelvinMul> for f64 {
    type Output = Quantity<f64, UnitKelvin>;
    fn mul(self, _: UnitKelvinMul) -> Self::Output {
        Quantity::new(self, UnitKelvin)
    }
}
pub struct UnitQuettakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakelvin {
    #[inline]
    fn clone(&self) -> UnitQuettakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakelvin {
    #[inline]
    fn eq(&self, other: &UnitQuettakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettakelvin {
    fn default() -> Self {
        UnitQuettakelvin
    }
}
impl Add<UnitQuettakelvin> for UnitQuettakelvin {
    type Output = UnitQuettakelvin;
    #[inline]
    fn add(self, _: UnitQuettakelvin) -> Self::Output {
        UnitQuettakelvin
    }
}
impl AddAssign<UnitQuettakelvin> for UnitQuettakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettakelvin) {}
}
impl Sub<UnitQuettakelvin> for UnitQuettakelvin {
    type Output = UnitQuettakelvin;
    #[inline]
    fn sub(self, _: UnitQuettakelvin) -> Self::Output {
        UnitQuettakelvin
    }
}
impl SubAssign<UnitQuettakelvin> for UnitQuettakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettakelvin) {}
}
pub struct UnitQuettakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakelvinMul {
    #[inline]
    fn clone(&self) -> UnitQuettakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitQuettakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettakelvinMul> for i8 {
    type Output = Quantity<i8, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for i16 {
    type Output = Quantity<i16, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for i32 {
    type Output = Quantity<i32, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for i64 {
    type Output = Quantity<i64, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for i128 {
    type Output = Quantity<i128, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for isize {
    type Output = Quantity<isize, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for u8 {
    type Output = Quantity<u8, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for u16 {
    type Output = Quantity<u16, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for u32 {
    type Output = Quantity<u32, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for u64 {
    type Output = Quantity<u64, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for u128 {
    type Output = Quantity<u128, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for usize {
    type Output = Quantity<usize, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for f32 {
    type Output = Quantity<f32, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
impl Mul<UnitQuettakelvinMul> for f64 {
    type Output = Quantity<f64, UnitQuettakelvin>;
    fn mul(self, _: UnitQuettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuettakelvin)
    }
}
pub struct UnitRonnakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakelvin {
    #[inline]
    fn clone(&self) -> UnitRonnakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakelvin {
    #[inline]
    fn eq(&self, other: &UnitRonnakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnakelvin {
    fn default() -> Self {
        UnitRonnakelvin
    }
}
impl Add<UnitRonnakelvin> for UnitRonnakelvin {
    type Output = UnitRonnakelvin;
    #[inline]
    fn add(self, _: UnitRonnakelvin) -> Self::Output {
        UnitRonnakelvin
    }
}
impl AddAssign<UnitRonnakelvin> for UnitRonnakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnakelvin) {}
}
impl Sub<UnitRonnakelvin> for UnitRonnakelvin {
    type Output = UnitRonnakelvin;
    #[inline]
    fn sub(self, _: UnitRonnakelvin) -> Self::Output {
        UnitRonnakelvin
    }
}
impl SubAssign<UnitRonnakelvin> for UnitRonnakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnakelvin) {}
}
pub struct UnitRonnakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakelvinMul {
    #[inline]
    fn clone(&self) -> UnitRonnakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitRonnakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnakelvinMul> for i8 {
    type Output = Quantity<i8, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for i16 {
    type Output = Quantity<i16, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for i32 {
    type Output = Quantity<i32, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for i64 {
    type Output = Quantity<i64, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for i128 {
    type Output = Quantity<i128, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for isize {
    type Output = Quantity<isize, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for u8 {
    type Output = Quantity<u8, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for u16 {
    type Output = Quantity<u16, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for u32 {
    type Output = Quantity<u32, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for u64 {
    type Output = Quantity<u64, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for u128 {
    type Output = Quantity<u128, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for usize {
    type Output = Quantity<usize, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for f32 {
    type Output = Quantity<f32, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
impl Mul<UnitRonnakelvinMul> for f64 {
    type Output = Quantity<f64, UnitRonnakelvin>;
    fn mul(self, _: UnitRonnakelvinMul) -> Self::Output {
        Quantity::new(self, UnitRonnakelvin)
    }
}
pub struct UnitYottakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakelvin {
    #[inline]
    fn clone(&self) -> UnitYottakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakelvin {
    #[inline]
    fn eq(&self, other: &UnitYottakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottakelvin {
    fn default() -> Self {
        UnitYottakelvin
    }
}
impl Add<UnitYottakelvin> for UnitYottakelvin {
    type Output = UnitYottakelvin;
    #[inline]
    fn add(self, _: UnitYottakelvin) -> Self::Output {
        UnitYottakelvin
    }
}
impl AddAssign<UnitYottakelvin> for UnitYottakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitYottakelvin) {}
}
impl Sub<UnitYottakelvin> for UnitYottakelvin {
    type Output = UnitYottakelvin;
    #[inline]
    fn sub(self, _: UnitYottakelvin) -> Self::Output {
        UnitYottakelvin
    }
}
impl SubAssign<UnitYottakelvin> for UnitYottakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottakelvin) {}
}
pub struct UnitYottakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakelvinMul {
    #[inline]
    fn clone(&self) -> UnitYottakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitYottakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottakelvinMul> for i8 {
    type Output = Quantity<i8, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for i16 {
    type Output = Quantity<i16, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for i32 {
    type Output = Quantity<i32, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for i64 {
    type Output = Quantity<i64, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for i128 {
    type Output = Quantity<i128, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for isize {
    type Output = Quantity<isize, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for u8 {
    type Output = Quantity<u8, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for u16 {
    type Output = Quantity<u16, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for u32 {
    type Output = Quantity<u32, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for u64 {
    type Output = Quantity<u64, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for u128 {
    type Output = Quantity<u128, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for usize {
    type Output = Quantity<usize, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for f32 {
    type Output = Quantity<f32, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
impl Mul<UnitYottakelvinMul> for f64 {
    type Output = Quantity<f64, UnitYottakelvin>;
    fn mul(self, _: UnitYottakelvinMul) -> Self::Output {
        Quantity::new(self, UnitYottakelvin)
    }
}
pub struct UnitZettakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakelvin {
    #[inline]
    fn clone(&self) -> UnitZettakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakelvin {
    #[inline]
    fn eq(&self, other: &UnitZettakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettakelvin {
    fn default() -> Self {
        UnitZettakelvin
    }
}
impl Add<UnitZettakelvin> for UnitZettakelvin {
    type Output = UnitZettakelvin;
    #[inline]
    fn add(self, _: UnitZettakelvin) -> Self::Output {
        UnitZettakelvin
    }
}
impl AddAssign<UnitZettakelvin> for UnitZettakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitZettakelvin) {}
}
impl Sub<UnitZettakelvin> for UnitZettakelvin {
    type Output = UnitZettakelvin;
    #[inline]
    fn sub(self, _: UnitZettakelvin) -> Self::Output {
        UnitZettakelvin
    }
}
impl SubAssign<UnitZettakelvin> for UnitZettakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettakelvin) {}
}
pub struct UnitZettakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakelvinMul {
    #[inline]
    fn clone(&self) -> UnitZettakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitZettakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettakelvinMul> for i8 {
    type Output = Quantity<i8, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for i16 {
    type Output = Quantity<i16, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for i32 {
    type Output = Quantity<i32, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for i64 {
    type Output = Quantity<i64, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for i128 {
    type Output = Quantity<i128, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for isize {
    type Output = Quantity<isize, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for u8 {
    type Output = Quantity<u8, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for u16 {
    type Output = Quantity<u16, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for u32 {
    type Output = Quantity<u32, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for u64 {
    type Output = Quantity<u64, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for u128 {
    type Output = Quantity<u128, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for usize {
    type Output = Quantity<usize, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for f32 {
    type Output = Quantity<f32, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
impl Mul<UnitZettakelvinMul> for f64 {
    type Output = Quantity<f64, UnitZettakelvin>;
    fn mul(self, _: UnitZettakelvinMul) -> Self::Output {
        Quantity::new(self, UnitZettakelvin)
    }
}
pub struct UnitExakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakelvin {
    #[inline]
    fn clone(&self) -> UnitExakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakelvin {
    #[inline]
    fn eq(&self, other: &UnitExakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExakelvin {
    fn default() -> Self {
        UnitExakelvin
    }
}
impl Add<UnitExakelvin> for UnitExakelvin {
    type Output = UnitExakelvin;
    #[inline]
    fn add(self, _: UnitExakelvin) -> Self::Output {
        UnitExakelvin
    }
}
impl AddAssign<UnitExakelvin> for UnitExakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitExakelvin) {}
}
impl Sub<UnitExakelvin> for UnitExakelvin {
    type Output = UnitExakelvin;
    #[inline]
    fn sub(self, _: UnitExakelvin) -> Self::Output {
        UnitExakelvin
    }
}
impl SubAssign<UnitExakelvin> for UnitExakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitExakelvin) {}
}
pub struct UnitExakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakelvinMul {
    #[inline]
    fn clone(&self) -> UnitExakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitExakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExakelvinMul> for i8 {
    type Output = Quantity<i8, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for i16 {
    type Output = Quantity<i16, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for i32 {
    type Output = Quantity<i32, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for i64 {
    type Output = Quantity<i64, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for i128 {
    type Output = Quantity<i128, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for isize {
    type Output = Quantity<isize, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for u8 {
    type Output = Quantity<u8, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for u16 {
    type Output = Quantity<u16, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for u32 {
    type Output = Quantity<u32, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for u64 {
    type Output = Quantity<u64, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for u128 {
    type Output = Quantity<u128, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for usize {
    type Output = Quantity<usize, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for f32 {
    type Output = Quantity<f32, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
impl Mul<UnitExakelvinMul> for f64 {
    type Output = Quantity<f64, UnitExakelvin>;
    fn mul(self, _: UnitExakelvinMul) -> Self::Output {
        Quantity::new(self, UnitExakelvin)
    }
}
pub struct UnitPetakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakelvin {
    #[inline]
    fn clone(&self) -> UnitPetakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakelvin {
    #[inline]
    fn eq(&self, other: &UnitPetakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetakelvin {
    fn default() -> Self {
        UnitPetakelvin
    }
}
impl Add<UnitPetakelvin> for UnitPetakelvin {
    type Output = UnitPetakelvin;
    #[inline]
    fn add(self, _: UnitPetakelvin) -> Self::Output {
        UnitPetakelvin
    }
}
impl AddAssign<UnitPetakelvin> for UnitPetakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitPetakelvin) {}
}
impl Sub<UnitPetakelvin> for UnitPetakelvin {
    type Output = UnitPetakelvin;
    #[inline]
    fn sub(self, _: UnitPetakelvin) -> Self::Output {
        UnitPetakelvin
    }
}
impl SubAssign<UnitPetakelvin> for UnitPetakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetakelvin) {}
}
pub struct UnitPetakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakelvinMul {
    #[inline]
    fn clone(&self) -> UnitPetakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitPetakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetakelvinMul> for i8 {
    type Output = Quantity<i8, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for i16 {
    type Output = Quantity<i16, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for i32 {
    type Output = Quantity<i32, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for i64 {
    type Output = Quantity<i64, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for i128 {
    type Output = Quantity<i128, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for isize {
    type Output = Quantity<isize, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for u8 {
    type Output = Quantity<u8, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for u16 {
    type Output = Quantity<u16, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for u32 {
    type Output = Quantity<u32, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for u64 {
    type Output = Quantity<u64, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for u128 {
    type Output = Quantity<u128, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for usize {
    type Output = Quantity<usize, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for f32 {
    type Output = Quantity<f32, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
impl Mul<UnitPetakelvinMul> for f64 {
    type Output = Quantity<f64, UnitPetakelvin>;
    fn mul(self, _: UnitPetakelvinMul) -> Self::Output {
        Quantity::new(self, UnitPetakelvin)
    }
}
pub struct UnitTerakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakelvin {
    #[inline]
    fn clone(&self) -> UnitTerakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakelvin {
    #[inline]
    fn eq(&self, other: &UnitTerakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerakelvin {
    fn default() -> Self {
        UnitTerakelvin
    }
}
impl Add<UnitTerakelvin> for UnitTerakelvin {
    type Output = UnitTerakelvin;
    #[inline]
    fn add(self, _: UnitTerakelvin) -> Self::Output {
        UnitTerakelvin
    }
}
impl AddAssign<UnitTerakelvin> for UnitTerakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitTerakelvin) {}
}
impl Sub<UnitTerakelvin> for UnitTerakelvin {
    type Output = UnitTerakelvin;
    #[inline]
    fn sub(self, _: UnitTerakelvin) -> Self::Output {
        UnitTerakelvin
    }
}
impl SubAssign<UnitTerakelvin> for UnitTerakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerakelvin) {}
}
pub struct UnitTerakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakelvinMul {
    #[inline]
    fn clone(&self) -> UnitTerakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitTerakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerakelvinMul> for i8 {
    type Output = Quantity<i8, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for i16 {
    type Output = Quantity<i16, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for i32 {
    type Output = Quantity<i32, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for i64 {
    type Output = Quantity<i64, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for i128 {
    type Output = Quantity<i128, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for isize {
    type Output = Quantity<isize, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for u8 {
    type Output = Quantity<u8, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for u16 {
    type Output = Quantity<u16, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for u32 {
    type Output = Quantity<u32, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for u64 {
    type Output = Quantity<u64, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for u128 {
    type Output = Quantity<u128, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for usize {
    type Output = Quantity<usize, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for f32 {
    type Output = Quantity<f32, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
impl Mul<UnitTerakelvinMul> for f64 {
    type Output = Quantity<f64, UnitTerakelvin>;
    fn mul(self, _: UnitTerakelvinMul) -> Self::Output {
        Quantity::new(self, UnitTerakelvin)
    }
}
pub struct UnitGigakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakelvin {
    #[inline]
    fn clone(&self) -> UnitGigakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakelvin {
    #[inline]
    fn eq(&self, other: &UnitGigakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigakelvin {
    fn default() -> Self {
        UnitGigakelvin
    }
}
impl Add<UnitGigakelvin> for UnitGigakelvin {
    type Output = UnitGigakelvin;
    #[inline]
    fn add(self, _: UnitGigakelvin) -> Self::Output {
        UnitGigakelvin
    }
}
impl AddAssign<UnitGigakelvin> for UnitGigakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitGigakelvin) {}
}
impl Sub<UnitGigakelvin> for UnitGigakelvin {
    type Output = UnitGigakelvin;
    #[inline]
    fn sub(self, _: UnitGigakelvin) -> Self::Output {
        UnitGigakelvin
    }
}
impl SubAssign<UnitGigakelvin> for UnitGigakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigakelvin) {}
}
pub struct UnitGigakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakelvinMul {
    #[inline]
    fn clone(&self) -> UnitGigakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitGigakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigakelvinMul> for i8 {
    type Output = Quantity<i8, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for i16 {
    type Output = Quantity<i16, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for i32 {
    type Output = Quantity<i32, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for i64 {
    type Output = Quantity<i64, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for i128 {
    type Output = Quantity<i128, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for isize {
    type Output = Quantity<isize, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for u8 {
    type Output = Quantity<u8, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for u16 {
    type Output = Quantity<u16, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for u32 {
    type Output = Quantity<u32, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for u64 {
    type Output = Quantity<u64, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for u128 {
    type Output = Quantity<u128, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for usize {
    type Output = Quantity<usize, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for f32 {
    type Output = Quantity<f32, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
impl Mul<UnitGigakelvinMul> for f64 {
    type Output = Quantity<f64, UnitGigakelvin>;
    fn mul(self, _: UnitGigakelvinMul) -> Self::Output {
        Quantity::new(self, UnitGigakelvin)
    }
}
pub struct UnitMegakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakelvin {
    #[inline]
    fn clone(&self) -> UnitMegakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakelvin {
    #[inline]
    fn eq(&self, other: &UnitMegakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegakelvin {
    fn default() -> Self {
        UnitMegakelvin
    }
}
impl Add<UnitMegakelvin> for UnitMegakelvin {
    type Output = UnitMegakelvin;
    #[inline]
    fn add(self, _: UnitMegakelvin) -> Self::Output {
        UnitMegakelvin
    }
}
impl AddAssign<UnitMegakelvin> for UnitMegakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitMegakelvin) {}
}
impl Sub<UnitMegakelvin> for UnitMegakelvin {
    type Output = UnitMegakelvin;
    #[inline]
    fn sub(self, _: UnitMegakelvin) -> Self::Output {
        UnitMegakelvin
    }
}
impl SubAssign<UnitMegakelvin> for UnitMegakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegakelvin) {}
}
pub struct UnitMegakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakelvinMul {
    #[inline]
    fn clone(&self) -> UnitMegakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitMegakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegakelvinMul> for i8 {
    type Output = Quantity<i8, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for i16 {
    type Output = Quantity<i16, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for i32 {
    type Output = Quantity<i32, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for i64 {
    type Output = Quantity<i64, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for i128 {
    type Output = Quantity<i128, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for isize {
    type Output = Quantity<isize, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for u8 {
    type Output = Quantity<u8, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for u16 {
    type Output = Quantity<u16, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for u32 {
    type Output = Quantity<u32, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for u64 {
    type Output = Quantity<u64, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for u128 {
    type Output = Quantity<u128, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for usize {
    type Output = Quantity<usize, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for f32 {
    type Output = Quantity<f32, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
impl Mul<UnitMegakelvinMul> for f64 {
    type Output = Quantity<f64, UnitMegakelvin>;
    fn mul(self, _: UnitMegakelvinMul) -> Self::Output {
        Quantity::new(self, UnitMegakelvin)
    }
}
pub struct UnitKilokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokelvin {
    #[inline]
    fn clone(&self) -> UnitKilokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokelvin {
    #[inline]
    fn eq(&self, other: &UnitKilokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilokelvin {
    fn default() -> Self {
        UnitKilokelvin
    }
}
impl Add<UnitKilokelvin> for UnitKilokelvin {
    type Output = UnitKilokelvin;
    #[inline]
    fn add(self, _: UnitKilokelvin) -> Self::Output {
        UnitKilokelvin
    }
}
impl AddAssign<UnitKilokelvin> for UnitKilokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitKilokelvin) {}
}
impl Sub<UnitKilokelvin> for UnitKilokelvin {
    type Output = UnitKilokelvin;
    #[inline]
    fn sub(self, _: UnitKilokelvin) -> Self::Output {
        UnitKilokelvin
    }
}
impl SubAssign<UnitKilokelvin> for UnitKilokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilokelvin) {}
}
pub struct UnitKilokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokelvinMul {
    #[inline]
    fn clone(&self) -> UnitKilokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitKilokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilokelvinMul> for i8 {
    type Output = Quantity<i8, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for i16 {
    type Output = Quantity<i16, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for i32 {
    type Output = Quantity<i32, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for i64 {
    type Output = Quantity<i64, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for i128 {
    type Output = Quantity<i128, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for isize {
    type Output = Quantity<isize, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for u8 {
    type Output = Quantity<u8, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for u16 {
    type Output = Quantity<u16, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for u32 {
    type Output = Quantity<u32, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for u64 {
    type Output = Quantity<u64, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for u128 {
    type Output = Quantity<u128, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for usize {
    type Output = Quantity<usize, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for f32 {
    type Output = Quantity<f32, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
impl Mul<UnitKilokelvinMul> for f64 {
    type Output = Quantity<f64, UnitKilokelvin>;
    fn mul(self, _: UnitKilokelvinMul) -> Self::Output {
        Quantity::new(self, UnitKilokelvin)
    }
}
pub struct UnitHectokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokelvin {
    #[inline]
    fn clone(&self) -> UnitHectokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokelvin {
    #[inline]
    fn eq(&self, other: &UnitHectokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectokelvin {
    fn default() -> Self {
        UnitHectokelvin
    }
}
impl Add<UnitHectokelvin> for UnitHectokelvin {
    type Output = UnitHectokelvin;
    #[inline]
    fn add(self, _: UnitHectokelvin) -> Self::Output {
        UnitHectokelvin
    }
}
impl AddAssign<UnitHectokelvin> for UnitHectokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitHectokelvin) {}
}
impl Sub<UnitHectokelvin> for UnitHectokelvin {
    type Output = UnitHectokelvin;
    #[inline]
    fn sub(self, _: UnitHectokelvin) -> Self::Output {
        UnitHectokelvin
    }
}
impl SubAssign<UnitHectokelvin> for UnitHectokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectokelvin) {}
}
pub struct UnitHectokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokelvinMul {
    #[inline]
    fn clone(&self) -> UnitHectokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitHectokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectokelvinMul> for i8 {
    type Output = Quantity<i8, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for i16 {
    type Output = Quantity<i16, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for i32 {
    type Output = Quantity<i32, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for i64 {
    type Output = Quantity<i64, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for i128 {
    type Output = Quantity<i128, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for isize {
    type Output = Quantity<isize, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for u8 {
    type Output = Quantity<u8, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for u16 {
    type Output = Quantity<u16, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for u32 {
    type Output = Quantity<u32, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for u64 {
    type Output = Quantity<u64, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for u128 {
    type Output = Quantity<u128, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for usize {
    type Output = Quantity<usize, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for f32 {
    type Output = Quantity<f32, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
impl Mul<UnitHectokelvinMul> for f64 {
    type Output = Quantity<f64, UnitHectokelvin>;
    fn mul(self, _: UnitHectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitHectokelvin)
    }
}
pub struct UnitDecakelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakelvin {
    #[inline]
    fn clone(&self) -> UnitDecakelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakelvin {
    #[inline]
    fn eq(&self, other: &UnitDecakelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecakelvin {
    fn default() -> Self {
        UnitDecakelvin
    }
}
impl Add<UnitDecakelvin> for UnitDecakelvin {
    type Output = UnitDecakelvin;
    #[inline]
    fn add(self, _: UnitDecakelvin) -> Self::Output {
        UnitDecakelvin
    }
}
impl AddAssign<UnitDecakelvin> for UnitDecakelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitDecakelvin) {}
}
impl Sub<UnitDecakelvin> for UnitDecakelvin {
    type Output = UnitDecakelvin;
    #[inline]
    fn sub(self, _: UnitDecakelvin) -> Self::Output {
        UnitDecakelvin
    }
}
impl SubAssign<UnitDecakelvin> for UnitDecakelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecakelvin) {}
}
pub struct UnitDecakelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakelvinMul {
    #[inline]
    fn clone(&self) -> UnitDecakelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakelvinMul {
    #[inline]
    fn eq(&self, other: &UnitDecakelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecakelvinMul> for i8 {
    type Output = Quantity<i8, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for i16 {
    type Output = Quantity<i16, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for i32 {
    type Output = Quantity<i32, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for i64 {
    type Output = Quantity<i64, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for i128 {
    type Output = Quantity<i128, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for isize {
    type Output = Quantity<isize, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for u8 {
    type Output = Quantity<u8, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for u16 {
    type Output = Quantity<u16, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for u32 {
    type Output = Quantity<u32, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for u64 {
    type Output = Quantity<u64, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for u128 {
    type Output = Quantity<u128, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for usize {
    type Output = Quantity<usize, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for f32 {
    type Output = Quantity<f32, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
impl Mul<UnitDecakelvinMul> for f64 {
    type Output = Quantity<f64, UnitDecakelvin>;
    fn mul(self, _: UnitDecakelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecakelvin)
    }
}
pub struct UnitDecikelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikelvin {
    #[inline]
    fn clone(&self) -> UnitDecikelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikelvin {
    #[inline]
    fn eq(&self, other: &UnitDecikelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecikelvin {
    fn default() -> Self {
        UnitDecikelvin
    }
}
impl Add<UnitDecikelvin> for UnitDecikelvin {
    type Output = UnitDecikelvin;
    #[inline]
    fn add(self, _: UnitDecikelvin) -> Self::Output {
        UnitDecikelvin
    }
}
impl AddAssign<UnitDecikelvin> for UnitDecikelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitDecikelvin) {}
}
impl Sub<UnitDecikelvin> for UnitDecikelvin {
    type Output = UnitDecikelvin;
    #[inline]
    fn sub(self, _: UnitDecikelvin) -> Self::Output {
        UnitDecikelvin
    }
}
impl SubAssign<UnitDecikelvin> for UnitDecikelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecikelvin) {}
}
pub struct UnitDecikelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikelvinMul {
    #[inline]
    fn clone(&self) -> UnitDecikelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikelvinMul {
    #[inline]
    fn eq(&self, other: &UnitDecikelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecikelvinMul> for i8 {
    type Output = Quantity<i8, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for i16 {
    type Output = Quantity<i16, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for i32 {
    type Output = Quantity<i32, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for i64 {
    type Output = Quantity<i64, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for i128 {
    type Output = Quantity<i128, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for isize {
    type Output = Quantity<isize, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for u8 {
    type Output = Quantity<u8, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for u16 {
    type Output = Quantity<u16, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for u32 {
    type Output = Quantity<u32, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for u64 {
    type Output = Quantity<u64, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for u128 {
    type Output = Quantity<u128, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for usize {
    type Output = Quantity<usize, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for f32 {
    type Output = Quantity<f32, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
impl Mul<UnitDecikelvinMul> for f64 {
    type Output = Quantity<f64, UnitDecikelvin>;
    fn mul(self, _: UnitDecikelvinMul) -> Self::Output {
        Quantity::new(self, UnitDecikelvin)
    }
}
pub struct UnitCentikelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikelvin {
    #[inline]
    fn clone(&self) -> UnitCentikelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikelvin {
    #[inline]
    fn eq(&self, other: &UnitCentikelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentikelvin {
    fn default() -> Self {
        UnitCentikelvin
    }
}
impl Add<UnitCentikelvin> for UnitCentikelvin {
    type Output = UnitCentikelvin;
    #[inline]
    fn add(self, _: UnitCentikelvin) -> Self::Output {
        UnitCentikelvin
    }
}
impl AddAssign<UnitCentikelvin> for UnitCentikelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitCentikelvin) {}
}
impl Sub<UnitCentikelvin> for UnitCentikelvin {
    type Output = UnitCentikelvin;
    #[inline]
    fn sub(self, _: UnitCentikelvin) -> Self::Output {
        UnitCentikelvin
    }
}
impl SubAssign<UnitCentikelvin> for UnitCentikelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentikelvin) {}
}
pub struct UnitCentikelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikelvinMul {
    #[inline]
    fn clone(&self) -> UnitCentikelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikelvinMul {
    #[inline]
    fn eq(&self, other: &UnitCentikelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentikelvinMul> for i8 {
    type Output = Quantity<i8, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for i16 {
    type Output = Quantity<i16, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for i32 {
    type Output = Quantity<i32, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for i64 {
    type Output = Quantity<i64, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for i128 {
    type Output = Quantity<i128, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for isize {
    type Output = Quantity<isize, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for u8 {
    type Output = Quantity<u8, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for u16 {
    type Output = Quantity<u16, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for u32 {
    type Output = Quantity<u32, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for u64 {
    type Output = Quantity<u64, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for u128 {
    type Output = Quantity<u128, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for usize {
    type Output = Quantity<usize, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for f32 {
    type Output = Quantity<f32, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
impl Mul<UnitCentikelvinMul> for f64 {
    type Output = Quantity<f64, UnitCentikelvin>;
    fn mul(self, _: UnitCentikelvinMul) -> Self::Output {
        Quantity::new(self, UnitCentikelvin)
    }
}
pub struct UnitMillikelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikelvin {
    #[inline]
    fn clone(&self) -> UnitMillikelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikelvin {
    #[inline]
    fn eq(&self, other: &UnitMillikelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillikelvin {
    fn default() -> Self {
        UnitMillikelvin
    }
}
impl Add<UnitMillikelvin> for UnitMillikelvin {
    type Output = UnitMillikelvin;
    #[inline]
    fn add(self, _: UnitMillikelvin) -> Self::Output {
        UnitMillikelvin
    }
}
impl AddAssign<UnitMillikelvin> for UnitMillikelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitMillikelvin) {}
}
impl Sub<UnitMillikelvin> for UnitMillikelvin {
    type Output = UnitMillikelvin;
    #[inline]
    fn sub(self, _: UnitMillikelvin) -> Self::Output {
        UnitMillikelvin
    }
}
impl SubAssign<UnitMillikelvin> for UnitMillikelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillikelvin) {}
}
pub struct UnitMillikelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikelvinMul {
    #[inline]
    fn clone(&self) -> UnitMillikelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikelvinMul {
    #[inline]
    fn eq(&self, other: &UnitMillikelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillikelvinMul> for i8 {
    type Output = Quantity<i8, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for i16 {
    type Output = Quantity<i16, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for i32 {
    type Output = Quantity<i32, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for i64 {
    type Output = Quantity<i64, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for i128 {
    type Output = Quantity<i128, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for isize {
    type Output = Quantity<isize, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for u8 {
    type Output = Quantity<u8, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for u16 {
    type Output = Quantity<u16, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for u32 {
    type Output = Quantity<u32, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for u64 {
    type Output = Quantity<u64, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for u128 {
    type Output = Quantity<u128, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for usize {
    type Output = Quantity<usize, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for f32 {
    type Output = Quantity<f32, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
impl Mul<UnitMillikelvinMul> for f64 {
    type Output = Quantity<f64, UnitMillikelvin>;
    fn mul(self, _: UnitMillikelvinMul) -> Self::Output {
        Quantity::new(self, UnitMillikelvin)
    }
}
pub struct UnitMicrokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokelvin {
    #[inline]
    fn clone(&self) -> UnitMicrokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokelvin {
    #[inline]
    fn eq(&self, other: &UnitMicrokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrokelvin {
    fn default() -> Self {
        UnitMicrokelvin
    }
}
impl Add<UnitMicrokelvin> for UnitMicrokelvin {
    type Output = UnitMicrokelvin;
    #[inline]
    fn add(self, _: UnitMicrokelvin) -> Self::Output {
        UnitMicrokelvin
    }
}
impl AddAssign<UnitMicrokelvin> for UnitMicrokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrokelvin) {}
}
impl Sub<UnitMicrokelvin> for UnitMicrokelvin {
    type Output = UnitMicrokelvin;
    #[inline]
    fn sub(self, _: UnitMicrokelvin) -> Self::Output {
        UnitMicrokelvin
    }
}
impl SubAssign<UnitMicrokelvin> for UnitMicrokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrokelvin) {}
}
pub struct UnitMicrokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokelvinMul {
    #[inline]
    fn clone(&self) -> UnitMicrokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitMicrokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrokelvinMul> for i8 {
    type Output = Quantity<i8, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for i16 {
    type Output = Quantity<i16, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for i32 {
    type Output = Quantity<i32, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for i64 {
    type Output = Quantity<i64, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for i128 {
    type Output = Quantity<i128, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for isize {
    type Output = Quantity<isize, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for u8 {
    type Output = Quantity<u8, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for u16 {
    type Output = Quantity<u16, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for u32 {
    type Output = Quantity<u32, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for u64 {
    type Output = Quantity<u64, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for u128 {
    type Output = Quantity<u128, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for usize {
    type Output = Quantity<usize, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for f32 {
    type Output = Quantity<f32, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
impl Mul<UnitMicrokelvinMul> for f64 {
    type Output = Quantity<f64, UnitMicrokelvin>;
    fn mul(self, _: UnitMicrokelvinMul) -> Self::Output {
        Quantity::new(self, UnitMicrokelvin)
    }
}
pub struct UnitNanokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokelvin {
    #[inline]
    fn clone(&self) -> UnitNanokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokelvin {
    #[inline]
    fn eq(&self, other: &UnitNanokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanokelvin {
    fn default() -> Self {
        UnitNanokelvin
    }
}
impl Add<UnitNanokelvin> for UnitNanokelvin {
    type Output = UnitNanokelvin;
    #[inline]
    fn add(self, _: UnitNanokelvin) -> Self::Output {
        UnitNanokelvin
    }
}
impl AddAssign<UnitNanokelvin> for UnitNanokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitNanokelvin) {}
}
impl Sub<UnitNanokelvin> for UnitNanokelvin {
    type Output = UnitNanokelvin;
    #[inline]
    fn sub(self, _: UnitNanokelvin) -> Self::Output {
        UnitNanokelvin
    }
}
impl SubAssign<UnitNanokelvin> for UnitNanokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanokelvin) {}
}
pub struct UnitNanokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokelvinMul {
    #[inline]
    fn clone(&self) -> UnitNanokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitNanokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanokelvinMul> for i8 {
    type Output = Quantity<i8, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for i16 {
    type Output = Quantity<i16, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for i32 {
    type Output = Quantity<i32, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for i64 {
    type Output = Quantity<i64, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for i128 {
    type Output = Quantity<i128, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for isize {
    type Output = Quantity<isize, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for u8 {
    type Output = Quantity<u8, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for u16 {
    type Output = Quantity<u16, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for u32 {
    type Output = Quantity<u32, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for u64 {
    type Output = Quantity<u64, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for u128 {
    type Output = Quantity<u128, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for usize {
    type Output = Quantity<usize, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for f32 {
    type Output = Quantity<f32, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
impl Mul<UnitNanokelvinMul> for f64 {
    type Output = Quantity<f64, UnitNanokelvin>;
    fn mul(self, _: UnitNanokelvinMul) -> Self::Output {
        Quantity::new(self, UnitNanokelvin)
    }
}
pub struct UnitPicokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokelvin {
    #[inline]
    fn clone(&self) -> UnitPicokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokelvin {
    #[inline]
    fn eq(&self, other: &UnitPicokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicokelvin {
    fn default() -> Self {
        UnitPicokelvin
    }
}
impl Add<UnitPicokelvin> for UnitPicokelvin {
    type Output = UnitPicokelvin;
    #[inline]
    fn add(self, _: UnitPicokelvin) -> Self::Output {
        UnitPicokelvin
    }
}
impl AddAssign<UnitPicokelvin> for UnitPicokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitPicokelvin) {}
}
impl Sub<UnitPicokelvin> for UnitPicokelvin {
    type Output = UnitPicokelvin;
    #[inline]
    fn sub(self, _: UnitPicokelvin) -> Self::Output {
        UnitPicokelvin
    }
}
impl SubAssign<UnitPicokelvin> for UnitPicokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicokelvin) {}
}
pub struct UnitPicokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokelvinMul {
    #[inline]
    fn clone(&self) -> UnitPicokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitPicokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicokelvinMul> for i8 {
    type Output = Quantity<i8, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for i16 {
    type Output = Quantity<i16, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for i32 {
    type Output = Quantity<i32, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for i64 {
    type Output = Quantity<i64, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for i128 {
    type Output = Quantity<i128, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for isize {
    type Output = Quantity<isize, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for u8 {
    type Output = Quantity<u8, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for u16 {
    type Output = Quantity<u16, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for u32 {
    type Output = Quantity<u32, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for u64 {
    type Output = Quantity<u64, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for u128 {
    type Output = Quantity<u128, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for usize {
    type Output = Quantity<usize, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for f32 {
    type Output = Quantity<f32, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
impl Mul<UnitPicokelvinMul> for f64 {
    type Output = Quantity<f64, UnitPicokelvin>;
    fn mul(self, _: UnitPicokelvinMul) -> Self::Output {
        Quantity::new(self, UnitPicokelvin)
    }
}
pub struct UnitFemtokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokelvin {
    #[inline]
    fn clone(&self) -> UnitFemtokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokelvin {
    #[inline]
    fn eq(&self, other: &UnitFemtokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtokelvin {
    fn default() -> Self {
        UnitFemtokelvin
    }
}
impl Add<UnitFemtokelvin> for UnitFemtokelvin {
    type Output = UnitFemtokelvin;
    #[inline]
    fn add(self, _: UnitFemtokelvin) -> Self::Output {
        UnitFemtokelvin
    }
}
impl AddAssign<UnitFemtokelvin> for UnitFemtokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtokelvin) {}
}
impl Sub<UnitFemtokelvin> for UnitFemtokelvin {
    type Output = UnitFemtokelvin;
    #[inline]
    fn sub(self, _: UnitFemtokelvin) -> Self::Output {
        UnitFemtokelvin
    }
}
impl SubAssign<UnitFemtokelvin> for UnitFemtokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtokelvin) {}
}
pub struct UnitFemtokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokelvinMul {
    #[inline]
    fn clone(&self) -> UnitFemtokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitFemtokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtokelvinMul> for i8 {
    type Output = Quantity<i8, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for i16 {
    type Output = Quantity<i16, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for i32 {
    type Output = Quantity<i32, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for i64 {
    type Output = Quantity<i64, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for i128 {
    type Output = Quantity<i128, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for isize {
    type Output = Quantity<isize, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for u8 {
    type Output = Quantity<u8, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for u16 {
    type Output = Quantity<u16, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for u32 {
    type Output = Quantity<u32, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for u64 {
    type Output = Quantity<u64, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for u128 {
    type Output = Quantity<u128, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for usize {
    type Output = Quantity<usize, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for f32 {
    type Output = Quantity<f32, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
impl Mul<UnitFemtokelvinMul> for f64 {
    type Output = Quantity<f64, UnitFemtokelvin>;
    fn mul(self, _: UnitFemtokelvinMul) -> Self::Output {
        Quantity::new(self, UnitFemtokelvin)
    }
}
pub struct UnitAttokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokelvin {
    #[inline]
    fn clone(&self) -> UnitAttokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokelvin {
    #[inline]
    fn eq(&self, other: &UnitAttokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttokelvin {
    fn default() -> Self {
        UnitAttokelvin
    }
}
impl Add<UnitAttokelvin> for UnitAttokelvin {
    type Output = UnitAttokelvin;
    #[inline]
    fn add(self, _: UnitAttokelvin) -> Self::Output {
        UnitAttokelvin
    }
}
impl AddAssign<UnitAttokelvin> for UnitAttokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitAttokelvin) {}
}
impl Sub<UnitAttokelvin> for UnitAttokelvin {
    type Output = UnitAttokelvin;
    #[inline]
    fn sub(self, _: UnitAttokelvin) -> Self::Output {
        UnitAttokelvin
    }
}
impl SubAssign<UnitAttokelvin> for UnitAttokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttokelvin) {}
}
pub struct UnitAttokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokelvinMul {
    #[inline]
    fn clone(&self) -> UnitAttokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitAttokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttokelvinMul> for i8 {
    type Output = Quantity<i8, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for i16 {
    type Output = Quantity<i16, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for i32 {
    type Output = Quantity<i32, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for i64 {
    type Output = Quantity<i64, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for i128 {
    type Output = Quantity<i128, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for isize {
    type Output = Quantity<isize, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for u8 {
    type Output = Quantity<u8, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for u16 {
    type Output = Quantity<u16, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for u32 {
    type Output = Quantity<u32, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for u64 {
    type Output = Quantity<u64, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for u128 {
    type Output = Quantity<u128, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for usize {
    type Output = Quantity<usize, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for f32 {
    type Output = Quantity<f32, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
impl Mul<UnitAttokelvinMul> for f64 {
    type Output = Quantity<f64, UnitAttokelvin>;
    fn mul(self, _: UnitAttokelvinMul) -> Self::Output {
        Quantity::new(self, UnitAttokelvin)
    }
}
pub struct UnitZeptokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokelvin {
    #[inline]
    fn clone(&self) -> UnitZeptokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokelvin {
    #[inline]
    fn eq(&self, other: &UnitZeptokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptokelvin {
    fn default() -> Self {
        UnitZeptokelvin
    }
}
impl Add<UnitZeptokelvin> for UnitZeptokelvin {
    type Output = UnitZeptokelvin;
    #[inline]
    fn add(self, _: UnitZeptokelvin) -> Self::Output {
        UnitZeptokelvin
    }
}
impl AddAssign<UnitZeptokelvin> for UnitZeptokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptokelvin) {}
}
impl Sub<UnitZeptokelvin> for UnitZeptokelvin {
    type Output = UnitZeptokelvin;
    #[inline]
    fn sub(self, _: UnitZeptokelvin) -> Self::Output {
        UnitZeptokelvin
    }
}
impl SubAssign<UnitZeptokelvin> for UnitZeptokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptokelvin) {}
}
pub struct UnitZeptokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokelvinMul {
    #[inline]
    fn clone(&self) -> UnitZeptokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitZeptokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptokelvinMul> for i8 {
    type Output = Quantity<i8, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for i16 {
    type Output = Quantity<i16, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for i32 {
    type Output = Quantity<i32, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for i64 {
    type Output = Quantity<i64, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for i128 {
    type Output = Quantity<i128, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for isize {
    type Output = Quantity<isize, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for u8 {
    type Output = Quantity<u8, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for u16 {
    type Output = Quantity<u16, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for u32 {
    type Output = Quantity<u32, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for u64 {
    type Output = Quantity<u64, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for u128 {
    type Output = Quantity<u128, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for usize {
    type Output = Quantity<usize, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for f32 {
    type Output = Quantity<f32, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
impl Mul<UnitZeptokelvinMul> for f64 {
    type Output = Quantity<f64, UnitZeptokelvin>;
    fn mul(self, _: UnitZeptokelvinMul) -> Self::Output {
        Quantity::new(self, UnitZeptokelvin)
    }
}
pub struct UnitYoctokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokelvin {
    #[inline]
    fn clone(&self) -> UnitYoctokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokelvin {
    #[inline]
    fn eq(&self, other: &UnitYoctokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctokelvin {
    fn default() -> Self {
        UnitYoctokelvin
    }
}
impl Add<UnitYoctokelvin> for UnitYoctokelvin {
    type Output = UnitYoctokelvin;
    #[inline]
    fn add(self, _: UnitYoctokelvin) -> Self::Output {
        UnitYoctokelvin
    }
}
impl AddAssign<UnitYoctokelvin> for UnitYoctokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctokelvin) {}
}
impl Sub<UnitYoctokelvin> for UnitYoctokelvin {
    type Output = UnitYoctokelvin;
    #[inline]
    fn sub(self, _: UnitYoctokelvin) -> Self::Output {
        UnitYoctokelvin
    }
}
impl SubAssign<UnitYoctokelvin> for UnitYoctokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctokelvin) {}
}
pub struct UnitYoctokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokelvinMul {
    #[inline]
    fn clone(&self) -> UnitYoctokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitYoctokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctokelvinMul> for i8 {
    type Output = Quantity<i8, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for i16 {
    type Output = Quantity<i16, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for i32 {
    type Output = Quantity<i32, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for i64 {
    type Output = Quantity<i64, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for i128 {
    type Output = Quantity<i128, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for isize {
    type Output = Quantity<isize, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for u8 {
    type Output = Quantity<u8, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for u16 {
    type Output = Quantity<u16, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for u32 {
    type Output = Quantity<u32, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for u64 {
    type Output = Quantity<u64, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for u128 {
    type Output = Quantity<u128, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for usize {
    type Output = Quantity<usize, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for f32 {
    type Output = Quantity<f32, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
impl Mul<UnitYoctokelvinMul> for f64 {
    type Output = Quantity<f64, UnitYoctokelvin>;
    fn mul(self, _: UnitYoctokelvinMul) -> Self::Output {
        Quantity::new(self, UnitYoctokelvin)
    }
}
pub struct UnitRontokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokelvin {
    #[inline]
    fn clone(&self) -> UnitRontokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokelvin {
    #[inline]
    fn eq(&self, other: &UnitRontokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontokelvin {
    fn default() -> Self {
        UnitRontokelvin
    }
}
impl Add<UnitRontokelvin> for UnitRontokelvin {
    type Output = UnitRontokelvin;
    #[inline]
    fn add(self, _: UnitRontokelvin) -> Self::Output {
        UnitRontokelvin
    }
}
impl AddAssign<UnitRontokelvin> for UnitRontokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitRontokelvin) {}
}
impl Sub<UnitRontokelvin> for UnitRontokelvin {
    type Output = UnitRontokelvin;
    #[inline]
    fn sub(self, _: UnitRontokelvin) -> Self::Output {
        UnitRontokelvin
    }
}
impl SubAssign<UnitRontokelvin> for UnitRontokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontokelvin) {}
}
pub struct UnitRontokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokelvinMul {
    #[inline]
    fn clone(&self) -> UnitRontokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitRontokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontokelvinMul> for i8 {
    type Output = Quantity<i8, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for i16 {
    type Output = Quantity<i16, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for i32 {
    type Output = Quantity<i32, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for i64 {
    type Output = Quantity<i64, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for i128 {
    type Output = Quantity<i128, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for isize {
    type Output = Quantity<isize, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for u8 {
    type Output = Quantity<u8, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for u16 {
    type Output = Quantity<u16, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for u32 {
    type Output = Quantity<u32, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for u64 {
    type Output = Quantity<u64, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for u128 {
    type Output = Quantity<u128, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for usize {
    type Output = Quantity<usize, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for f32 {
    type Output = Quantity<f32, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
impl Mul<UnitRontokelvinMul> for f64 {
    type Output = Quantity<f64, UnitRontokelvin>;
    fn mul(self, _: UnitRontokelvinMul) -> Self::Output {
        Quantity::new(self, UnitRontokelvin)
    }
}
pub struct UnitQuectokelvin;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokelvin {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokelvin")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokelvin {
    #[inline]
    fn clone(&self) -> UnitQuectokelvin {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokelvin {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokelvin {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokelvin {
    #[inline]
    fn eq(&self, other: &UnitQuectokelvin) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokelvin {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectokelvin {
    fn default() -> Self {
        UnitQuectokelvin
    }
}
impl Add<UnitQuectokelvin> for UnitQuectokelvin {
    type Output = UnitQuectokelvin;
    #[inline]
    fn add(self, _: UnitQuectokelvin) -> Self::Output {
        UnitQuectokelvin
    }
}
impl AddAssign<UnitQuectokelvin> for UnitQuectokelvin {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectokelvin) {}
}
impl Sub<UnitQuectokelvin> for UnitQuectokelvin {
    type Output = UnitQuectokelvin;
    #[inline]
    fn sub(self, _: UnitQuectokelvin) -> Self::Output {
        UnitQuectokelvin
    }
}
impl SubAssign<UnitQuectokelvin> for UnitQuectokelvin {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectokelvin) {}
}
pub struct UnitQuectokelvinMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokelvinMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokelvinMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokelvinMul {
    #[inline]
    fn clone(&self) -> UnitQuectokelvinMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokelvinMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokelvinMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokelvinMul {
    #[inline]
    fn eq(&self, other: &UnitQuectokelvinMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokelvinMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectokelvinMul> for i8 {
    type Output = Quantity<i8, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for i16 {
    type Output = Quantity<i16, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for i32 {
    type Output = Quantity<i32, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for i64 {
    type Output = Quantity<i64, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for i128 {
    type Output = Quantity<i128, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for isize {
    type Output = Quantity<isize, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for u8 {
    type Output = Quantity<u8, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for u16 {
    type Output = Quantity<u16, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for u32 {
    type Output = Quantity<u32, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for u64 {
    type Output = Quantity<u64, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for u128 {
    type Output = Quantity<u128, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for usize {
    type Output = Quantity<usize, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for f32 {
    type Output = Quantity<f32, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
impl Mul<UnitQuectokelvinMul> for f64 {
    type Output = Quantity<f64, UnitQuectokelvin>;
    fn mul(self, _: UnitQuectokelvinMul) -> Self::Output {
        Quantity::new(self, UnitQuectokelvin)
    }
}
pub type Kelvin<T> = Quantity<T, UnitKelvin>;
#[allow(non_upper_case_globals)]
pub static Kelvin: UnitKelvinMul = UnitKelvinMul;
pub type Quettakelvin<T> = Quantity<T, UnitQuettakelvin>;
#[allow(non_upper_case_globals)]
pub static Quettakelvin: UnitQuettakelvinMul = UnitQuettakelvinMul;
pub type Ronnakelvin<T> = Quantity<T, UnitRonnakelvin>;
#[allow(non_upper_case_globals)]
pub static Ronnakelvin: UnitRonnakelvinMul = UnitRonnakelvinMul;
pub type Yottakelvin<T> = Quantity<T, UnitYottakelvin>;
#[allow(non_upper_case_globals)]
pub static Yottakelvin: UnitYottakelvinMul = UnitYottakelvinMul;
pub type Zettakelvin<T> = Quantity<T, UnitZettakelvin>;
#[allow(non_upper_case_globals)]
pub static Zettakelvin: UnitZettakelvinMul = UnitZettakelvinMul;
pub type Exakelvin<T> = Quantity<T, UnitExakelvin>;
#[allow(non_upper_case_globals)]
pub static Exakelvin: UnitExakelvinMul = UnitExakelvinMul;
pub type Petakelvin<T> = Quantity<T, UnitPetakelvin>;
#[allow(non_upper_case_globals)]
pub static Petakelvin: UnitPetakelvinMul = UnitPetakelvinMul;
pub type Terakelvin<T> = Quantity<T, UnitTerakelvin>;
#[allow(non_upper_case_globals)]
pub static Terakelvin: UnitTerakelvinMul = UnitTerakelvinMul;
pub type Gigakelvin<T> = Quantity<T, UnitGigakelvin>;
#[allow(non_upper_case_globals)]
pub static Gigakelvin: UnitGigakelvinMul = UnitGigakelvinMul;
pub type Megakelvin<T> = Quantity<T, UnitMegakelvin>;
#[allow(non_upper_case_globals)]
pub static Megakelvin: UnitMegakelvinMul = UnitMegakelvinMul;
pub type Kilokelvin<T> = Quantity<T, UnitKilokelvin>;
#[allow(non_upper_case_globals)]
pub static Kilokelvin: UnitKilokelvinMul = UnitKilokelvinMul;
pub type Hectokelvin<T> = Quantity<T, UnitHectokelvin>;
#[allow(non_upper_case_globals)]
pub static Hectokelvin: UnitHectokelvinMul = UnitHectokelvinMul;
pub type Decakelvin<T> = Quantity<T, UnitDecakelvin>;
#[allow(non_upper_case_globals)]
pub static Decakelvin: UnitDecakelvinMul = UnitDecakelvinMul;
pub type Decikelvin<T> = Quantity<T, UnitDecikelvin>;
#[allow(non_upper_case_globals)]
pub static Decikelvin: UnitDecikelvinMul = UnitDecikelvinMul;
pub type Centikelvin<T> = Quantity<T, UnitCentikelvin>;
#[allow(non_upper_case_globals)]
pub static Centikelvin: UnitCentikelvinMul = UnitCentikelvinMul;
pub type Millikelvin<T> = Quantity<T, UnitMillikelvin>;
#[allow(non_upper_case_globals)]
pub static Millikelvin: UnitMillikelvinMul = UnitMillikelvinMul;
pub type Microkelvin<T> = Quantity<T, UnitMicrokelvin>;
#[allow(non_upper_case_globals)]
pub static Microkelvin: UnitMicrokelvinMul = UnitMicrokelvinMul;
pub type Nanokelvin<T> = Quantity<T, UnitNanokelvin>;
#[allow(non_upper_case_globals)]
pub static Nanokelvin: UnitNanokelvinMul = UnitNanokelvinMul;
pub type Picokelvin<T> = Quantity<T, UnitPicokelvin>;
#[allow(non_upper_case_globals)]
pub static Picokelvin: UnitPicokelvinMul = UnitPicokelvinMul;
pub type Femtokelvin<T> = Quantity<T, UnitFemtokelvin>;
#[allow(non_upper_case_globals)]
pub static Femtokelvin: UnitFemtokelvinMul = UnitFemtokelvinMul;
pub type Attokelvin<T> = Quantity<T, UnitAttokelvin>;
#[allow(non_upper_case_globals)]
pub static Attokelvin: UnitAttokelvinMul = UnitAttokelvinMul;
pub type Zeptokelvin<T> = Quantity<T, UnitZeptokelvin>;
#[allow(non_upper_case_globals)]
pub static Zeptokelvin: UnitZeptokelvinMul = UnitZeptokelvinMul;
pub type Yoctokelvin<T> = Quantity<T, UnitYoctokelvin>;
#[allow(non_upper_case_globals)]
pub static Yoctokelvin: UnitYoctokelvinMul = UnitYoctokelvinMul;
pub type Rontokelvin<T> = Quantity<T, UnitRontokelvin>;
#[allow(non_upper_case_globals)]
pub static Rontokelvin: UnitRontokelvinMul = UnitRontokelvinMul;
pub type Quectokelvin<T> = Quantity<T, UnitQuectokelvin>;
#[allow(non_upper_case_globals)]
pub static Quectokelvin: UnitQuectokelvinMul = UnitQuectokelvinMul;
pub struct UnitMoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMoles {
    #[inline]
    fn clone(&self) -> UnitMoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMoles {
    #[inline]
    fn eq(&self, other: &UnitMoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMoles {
    fn default() -> Self {
        UnitMoles
    }
}
impl Add<UnitMoles> for UnitMoles {
    type Output = UnitMoles;
    #[inline]
    fn add(self, _: UnitMoles) -> Self::Output {
        UnitMoles
    }
}
impl AddAssign<UnitMoles> for UnitMoles {
    #[inline]
    fn add_assign(&mut self, _: UnitMoles) {}
}
impl Sub<UnitMoles> for UnitMoles {
    type Output = UnitMoles;
    #[inline]
    fn sub(self, _: UnitMoles) -> Self::Output {
        UnitMoles
    }
}
impl SubAssign<UnitMoles> for UnitMoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitMoles) {}
}
pub struct UnitMolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMolesMul {
    #[inline]
    fn clone(&self) -> UnitMolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMolesMul {
    #[inline]
    fn eq(&self, other: &UnitMolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMolesMul> for i8 {
    type Output = Quantity<i8, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for i16 {
    type Output = Quantity<i16, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for i32 {
    type Output = Quantity<i32, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for i64 {
    type Output = Quantity<i64, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for i128 {
    type Output = Quantity<i128, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for isize {
    type Output = Quantity<isize, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for u8 {
    type Output = Quantity<u8, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for u16 {
    type Output = Quantity<u16, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for u32 {
    type Output = Quantity<u32, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for u64 {
    type Output = Quantity<u64, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for u128 {
    type Output = Quantity<u128, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for usize {
    type Output = Quantity<usize, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for f32 {
    type Output = Quantity<f32, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
impl Mul<UnitMolesMul> for f64 {
    type Output = Quantity<f64, UnitMoles>;
    fn mul(self, _: UnitMolesMul) -> Self::Output {
        Quantity::new(self, UnitMoles)
    }
}
pub struct UnitQuettamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettamoles {
    #[inline]
    fn clone(&self) -> UnitQuettamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettamoles {
    #[inline]
    fn eq(&self, other: &UnitQuettamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettamoles {
    fn default() -> Self {
        UnitQuettamoles
    }
}
impl Add<UnitQuettamoles> for UnitQuettamoles {
    type Output = UnitQuettamoles;
    #[inline]
    fn add(self, _: UnitQuettamoles) -> Self::Output {
        UnitQuettamoles
    }
}
impl AddAssign<UnitQuettamoles> for UnitQuettamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettamoles) {}
}
impl Sub<UnitQuettamoles> for UnitQuettamoles {
    type Output = UnitQuettamoles;
    #[inline]
    fn sub(self, _: UnitQuettamoles) -> Self::Output {
        UnitQuettamoles
    }
}
impl SubAssign<UnitQuettamoles> for UnitQuettamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettamoles) {}
}
pub struct UnitQuettamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettamolesMul {
    #[inline]
    fn clone(&self) -> UnitQuettamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettamolesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettamolesMul> for i8 {
    type Output = Quantity<i8, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for i16 {
    type Output = Quantity<i16, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for i32 {
    type Output = Quantity<i32, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for i64 {
    type Output = Quantity<i64, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for i128 {
    type Output = Quantity<i128, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for isize {
    type Output = Quantity<isize, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for u8 {
    type Output = Quantity<u8, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for u16 {
    type Output = Quantity<u16, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for u32 {
    type Output = Quantity<u32, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for u64 {
    type Output = Quantity<u64, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for u128 {
    type Output = Quantity<u128, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for usize {
    type Output = Quantity<usize, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for f32 {
    type Output = Quantity<f32, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
impl Mul<UnitQuettamolesMul> for f64 {
    type Output = Quantity<f64, UnitQuettamoles>;
    fn mul(self, _: UnitQuettamolesMul) -> Self::Output {
        Quantity::new(self, UnitQuettamoles)
    }
}
pub struct UnitRonnamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnamoles {
    #[inline]
    fn clone(&self) -> UnitRonnamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnamoles {
    #[inline]
    fn eq(&self, other: &UnitRonnamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnamoles {
    fn default() -> Self {
        UnitRonnamoles
    }
}
impl Add<UnitRonnamoles> for UnitRonnamoles {
    type Output = UnitRonnamoles;
    #[inline]
    fn add(self, _: UnitRonnamoles) -> Self::Output {
        UnitRonnamoles
    }
}
impl AddAssign<UnitRonnamoles> for UnitRonnamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnamoles) {}
}
impl Sub<UnitRonnamoles> for UnitRonnamoles {
    type Output = UnitRonnamoles;
    #[inline]
    fn sub(self, _: UnitRonnamoles) -> Self::Output {
        UnitRonnamoles
    }
}
impl SubAssign<UnitRonnamoles> for UnitRonnamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnamoles) {}
}
pub struct UnitRonnamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnamolesMul {
    #[inline]
    fn clone(&self) -> UnitRonnamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnamolesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnamolesMul> for i8 {
    type Output = Quantity<i8, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for i16 {
    type Output = Quantity<i16, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for i32 {
    type Output = Quantity<i32, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for i64 {
    type Output = Quantity<i64, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for i128 {
    type Output = Quantity<i128, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for isize {
    type Output = Quantity<isize, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for u8 {
    type Output = Quantity<u8, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for u16 {
    type Output = Quantity<u16, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for u32 {
    type Output = Quantity<u32, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for u64 {
    type Output = Quantity<u64, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for u128 {
    type Output = Quantity<u128, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for usize {
    type Output = Quantity<usize, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for f32 {
    type Output = Quantity<f32, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
impl Mul<UnitRonnamolesMul> for f64 {
    type Output = Quantity<f64, UnitRonnamoles>;
    fn mul(self, _: UnitRonnamolesMul) -> Self::Output {
        Quantity::new(self, UnitRonnamoles)
    }
}
pub struct UnitYottamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottamoles {
    #[inline]
    fn clone(&self) -> UnitYottamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottamoles {
    #[inline]
    fn eq(&self, other: &UnitYottamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottamoles {
    fn default() -> Self {
        UnitYottamoles
    }
}
impl Add<UnitYottamoles> for UnitYottamoles {
    type Output = UnitYottamoles;
    #[inline]
    fn add(self, _: UnitYottamoles) -> Self::Output {
        UnitYottamoles
    }
}
impl AddAssign<UnitYottamoles> for UnitYottamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitYottamoles) {}
}
impl Sub<UnitYottamoles> for UnitYottamoles {
    type Output = UnitYottamoles;
    #[inline]
    fn sub(self, _: UnitYottamoles) -> Self::Output {
        UnitYottamoles
    }
}
impl SubAssign<UnitYottamoles> for UnitYottamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottamoles) {}
}
pub struct UnitYottamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottamolesMul {
    #[inline]
    fn clone(&self) -> UnitYottamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottamolesMul {
    #[inline]
    fn eq(&self, other: &UnitYottamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottamolesMul> for i8 {
    type Output = Quantity<i8, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for i16 {
    type Output = Quantity<i16, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for i32 {
    type Output = Quantity<i32, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for i64 {
    type Output = Quantity<i64, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for i128 {
    type Output = Quantity<i128, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for isize {
    type Output = Quantity<isize, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for u8 {
    type Output = Quantity<u8, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for u16 {
    type Output = Quantity<u16, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for u32 {
    type Output = Quantity<u32, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for u64 {
    type Output = Quantity<u64, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for u128 {
    type Output = Quantity<u128, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for usize {
    type Output = Quantity<usize, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for f32 {
    type Output = Quantity<f32, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
impl Mul<UnitYottamolesMul> for f64 {
    type Output = Quantity<f64, UnitYottamoles>;
    fn mul(self, _: UnitYottamolesMul) -> Self::Output {
        Quantity::new(self, UnitYottamoles)
    }
}
pub struct UnitZettamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettamoles {
    #[inline]
    fn clone(&self) -> UnitZettamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettamoles {
    #[inline]
    fn eq(&self, other: &UnitZettamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettamoles {
    fn default() -> Self {
        UnitZettamoles
    }
}
impl Add<UnitZettamoles> for UnitZettamoles {
    type Output = UnitZettamoles;
    #[inline]
    fn add(self, _: UnitZettamoles) -> Self::Output {
        UnitZettamoles
    }
}
impl AddAssign<UnitZettamoles> for UnitZettamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitZettamoles) {}
}
impl Sub<UnitZettamoles> for UnitZettamoles {
    type Output = UnitZettamoles;
    #[inline]
    fn sub(self, _: UnitZettamoles) -> Self::Output {
        UnitZettamoles
    }
}
impl SubAssign<UnitZettamoles> for UnitZettamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettamoles) {}
}
pub struct UnitZettamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettamolesMul {
    #[inline]
    fn clone(&self) -> UnitZettamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettamolesMul {
    #[inline]
    fn eq(&self, other: &UnitZettamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettamolesMul> for i8 {
    type Output = Quantity<i8, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for i16 {
    type Output = Quantity<i16, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for i32 {
    type Output = Quantity<i32, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for i64 {
    type Output = Quantity<i64, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for i128 {
    type Output = Quantity<i128, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for isize {
    type Output = Quantity<isize, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for u8 {
    type Output = Quantity<u8, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for u16 {
    type Output = Quantity<u16, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for u32 {
    type Output = Quantity<u32, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for u64 {
    type Output = Quantity<u64, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for u128 {
    type Output = Quantity<u128, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for usize {
    type Output = Quantity<usize, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for f32 {
    type Output = Quantity<f32, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
impl Mul<UnitZettamolesMul> for f64 {
    type Output = Quantity<f64, UnitZettamoles>;
    fn mul(self, _: UnitZettamolesMul) -> Self::Output {
        Quantity::new(self, UnitZettamoles)
    }
}
pub struct UnitExamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExamoles {
    #[inline]
    fn clone(&self) -> UnitExamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExamoles {
    #[inline]
    fn eq(&self, other: &UnitExamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExamoles {
    fn default() -> Self {
        UnitExamoles
    }
}
impl Add<UnitExamoles> for UnitExamoles {
    type Output = UnitExamoles;
    #[inline]
    fn add(self, _: UnitExamoles) -> Self::Output {
        UnitExamoles
    }
}
impl AddAssign<UnitExamoles> for UnitExamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitExamoles) {}
}
impl Sub<UnitExamoles> for UnitExamoles {
    type Output = UnitExamoles;
    #[inline]
    fn sub(self, _: UnitExamoles) -> Self::Output {
        UnitExamoles
    }
}
impl SubAssign<UnitExamoles> for UnitExamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitExamoles) {}
}
pub struct UnitExamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExamolesMul {
    #[inline]
    fn clone(&self) -> UnitExamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExamolesMul {
    #[inline]
    fn eq(&self, other: &UnitExamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExamolesMul> for i8 {
    type Output = Quantity<i8, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for i16 {
    type Output = Quantity<i16, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for i32 {
    type Output = Quantity<i32, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for i64 {
    type Output = Quantity<i64, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for i128 {
    type Output = Quantity<i128, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for isize {
    type Output = Quantity<isize, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for u8 {
    type Output = Quantity<u8, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for u16 {
    type Output = Quantity<u16, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for u32 {
    type Output = Quantity<u32, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for u64 {
    type Output = Quantity<u64, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for u128 {
    type Output = Quantity<u128, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for usize {
    type Output = Quantity<usize, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for f32 {
    type Output = Quantity<f32, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
impl Mul<UnitExamolesMul> for f64 {
    type Output = Quantity<f64, UnitExamoles>;
    fn mul(self, _: UnitExamolesMul) -> Self::Output {
        Quantity::new(self, UnitExamoles)
    }
}
pub struct UnitPetamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetamoles {
    #[inline]
    fn clone(&self) -> UnitPetamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetamoles {
    #[inline]
    fn eq(&self, other: &UnitPetamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetamoles {
    fn default() -> Self {
        UnitPetamoles
    }
}
impl Add<UnitPetamoles> for UnitPetamoles {
    type Output = UnitPetamoles;
    #[inline]
    fn add(self, _: UnitPetamoles) -> Self::Output {
        UnitPetamoles
    }
}
impl AddAssign<UnitPetamoles> for UnitPetamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitPetamoles) {}
}
impl Sub<UnitPetamoles> for UnitPetamoles {
    type Output = UnitPetamoles;
    #[inline]
    fn sub(self, _: UnitPetamoles) -> Self::Output {
        UnitPetamoles
    }
}
impl SubAssign<UnitPetamoles> for UnitPetamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetamoles) {}
}
pub struct UnitPetamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetamolesMul {
    #[inline]
    fn clone(&self) -> UnitPetamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetamolesMul {
    #[inline]
    fn eq(&self, other: &UnitPetamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetamolesMul> for i8 {
    type Output = Quantity<i8, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for i16 {
    type Output = Quantity<i16, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for i32 {
    type Output = Quantity<i32, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for i64 {
    type Output = Quantity<i64, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for i128 {
    type Output = Quantity<i128, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for isize {
    type Output = Quantity<isize, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for u8 {
    type Output = Quantity<u8, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for u16 {
    type Output = Quantity<u16, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for u32 {
    type Output = Quantity<u32, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for u64 {
    type Output = Quantity<u64, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for u128 {
    type Output = Quantity<u128, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for usize {
    type Output = Quantity<usize, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for f32 {
    type Output = Quantity<f32, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
impl Mul<UnitPetamolesMul> for f64 {
    type Output = Quantity<f64, UnitPetamoles>;
    fn mul(self, _: UnitPetamolesMul) -> Self::Output {
        Quantity::new(self, UnitPetamoles)
    }
}
pub struct UnitTeramoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeramoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeramoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeramoles {
    #[inline]
    fn clone(&self) -> UnitTeramoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeramoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeramoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeramoles {
    #[inline]
    fn eq(&self, other: &UnitTeramoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeramoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeramoles {
    fn default() -> Self {
        UnitTeramoles
    }
}
impl Add<UnitTeramoles> for UnitTeramoles {
    type Output = UnitTeramoles;
    #[inline]
    fn add(self, _: UnitTeramoles) -> Self::Output {
        UnitTeramoles
    }
}
impl AddAssign<UnitTeramoles> for UnitTeramoles {
    #[inline]
    fn add_assign(&mut self, _: UnitTeramoles) {}
}
impl Sub<UnitTeramoles> for UnitTeramoles {
    type Output = UnitTeramoles;
    #[inline]
    fn sub(self, _: UnitTeramoles) -> Self::Output {
        UnitTeramoles
    }
}
impl SubAssign<UnitTeramoles> for UnitTeramoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeramoles) {}
}
pub struct UnitTeramolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeramolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeramolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeramolesMul {
    #[inline]
    fn clone(&self) -> UnitTeramolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeramolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeramolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeramolesMul {
    #[inline]
    fn eq(&self, other: &UnitTeramolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeramolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeramolesMul> for i8 {
    type Output = Quantity<i8, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for i16 {
    type Output = Quantity<i16, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for i32 {
    type Output = Quantity<i32, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for i64 {
    type Output = Quantity<i64, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for i128 {
    type Output = Quantity<i128, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for isize {
    type Output = Quantity<isize, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for u8 {
    type Output = Quantity<u8, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for u16 {
    type Output = Quantity<u16, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for u32 {
    type Output = Quantity<u32, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for u64 {
    type Output = Quantity<u64, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for u128 {
    type Output = Quantity<u128, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for usize {
    type Output = Quantity<usize, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for f32 {
    type Output = Quantity<f32, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
impl Mul<UnitTeramolesMul> for f64 {
    type Output = Quantity<f64, UnitTeramoles>;
    fn mul(self, _: UnitTeramolesMul) -> Self::Output {
        Quantity::new(self, UnitTeramoles)
    }
}
pub struct UnitGigamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigamoles {
    #[inline]
    fn clone(&self) -> UnitGigamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigamoles {
    #[inline]
    fn eq(&self, other: &UnitGigamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigamoles {
    fn default() -> Self {
        UnitGigamoles
    }
}
impl Add<UnitGigamoles> for UnitGigamoles {
    type Output = UnitGigamoles;
    #[inline]
    fn add(self, _: UnitGigamoles) -> Self::Output {
        UnitGigamoles
    }
}
impl AddAssign<UnitGigamoles> for UnitGigamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitGigamoles) {}
}
impl Sub<UnitGigamoles> for UnitGigamoles {
    type Output = UnitGigamoles;
    #[inline]
    fn sub(self, _: UnitGigamoles) -> Self::Output {
        UnitGigamoles
    }
}
impl SubAssign<UnitGigamoles> for UnitGigamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigamoles) {}
}
pub struct UnitGigamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigamolesMul {
    #[inline]
    fn clone(&self) -> UnitGigamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigamolesMul {
    #[inline]
    fn eq(&self, other: &UnitGigamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigamolesMul> for i8 {
    type Output = Quantity<i8, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for i16 {
    type Output = Quantity<i16, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for i32 {
    type Output = Quantity<i32, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for i64 {
    type Output = Quantity<i64, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for i128 {
    type Output = Quantity<i128, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for isize {
    type Output = Quantity<isize, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for u8 {
    type Output = Quantity<u8, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for u16 {
    type Output = Quantity<u16, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for u32 {
    type Output = Quantity<u32, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for u64 {
    type Output = Quantity<u64, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for u128 {
    type Output = Quantity<u128, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for usize {
    type Output = Quantity<usize, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for f32 {
    type Output = Quantity<f32, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
impl Mul<UnitGigamolesMul> for f64 {
    type Output = Quantity<f64, UnitGigamoles>;
    fn mul(self, _: UnitGigamolesMul) -> Self::Output {
        Quantity::new(self, UnitGigamoles)
    }
}
pub struct UnitMegamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegamoles {
    #[inline]
    fn clone(&self) -> UnitMegamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegamoles {
    #[inline]
    fn eq(&self, other: &UnitMegamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegamoles {
    fn default() -> Self {
        UnitMegamoles
    }
}
impl Add<UnitMegamoles> for UnitMegamoles {
    type Output = UnitMegamoles;
    #[inline]
    fn add(self, _: UnitMegamoles) -> Self::Output {
        UnitMegamoles
    }
}
impl AddAssign<UnitMegamoles> for UnitMegamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitMegamoles) {}
}
impl Sub<UnitMegamoles> for UnitMegamoles {
    type Output = UnitMegamoles;
    #[inline]
    fn sub(self, _: UnitMegamoles) -> Self::Output {
        UnitMegamoles
    }
}
impl SubAssign<UnitMegamoles> for UnitMegamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegamoles) {}
}
pub struct UnitMegamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegamolesMul {
    #[inline]
    fn clone(&self) -> UnitMegamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegamolesMul {
    #[inline]
    fn eq(&self, other: &UnitMegamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegamolesMul> for i8 {
    type Output = Quantity<i8, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for i16 {
    type Output = Quantity<i16, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for i32 {
    type Output = Quantity<i32, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for i64 {
    type Output = Quantity<i64, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for i128 {
    type Output = Quantity<i128, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for isize {
    type Output = Quantity<isize, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for u8 {
    type Output = Quantity<u8, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for u16 {
    type Output = Quantity<u16, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for u32 {
    type Output = Quantity<u32, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for u64 {
    type Output = Quantity<u64, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for u128 {
    type Output = Quantity<u128, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for usize {
    type Output = Quantity<usize, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for f32 {
    type Output = Quantity<f32, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
impl Mul<UnitMegamolesMul> for f64 {
    type Output = Quantity<f64, UnitMegamoles>;
    fn mul(self, _: UnitMegamolesMul) -> Self::Output {
        Quantity::new(self, UnitMegamoles)
    }
}
pub struct UnitKilomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilomoles {
    #[inline]
    fn clone(&self) -> UnitKilomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilomoles {
    #[inline]
    fn eq(&self, other: &UnitKilomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilomoles {
    fn default() -> Self {
        UnitKilomoles
    }
}
impl Add<UnitKilomoles> for UnitKilomoles {
    type Output = UnitKilomoles;
    #[inline]
    fn add(self, _: UnitKilomoles) -> Self::Output {
        UnitKilomoles
    }
}
impl AddAssign<UnitKilomoles> for UnitKilomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitKilomoles) {}
}
impl Sub<UnitKilomoles> for UnitKilomoles {
    type Output = UnitKilomoles;
    #[inline]
    fn sub(self, _: UnitKilomoles) -> Self::Output {
        UnitKilomoles
    }
}
impl SubAssign<UnitKilomoles> for UnitKilomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilomoles) {}
}
pub struct UnitKilomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilomolesMul {
    #[inline]
    fn clone(&self) -> UnitKilomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilomolesMul {
    #[inline]
    fn eq(&self, other: &UnitKilomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilomolesMul> for i8 {
    type Output = Quantity<i8, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for i16 {
    type Output = Quantity<i16, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for i32 {
    type Output = Quantity<i32, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for i64 {
    type Output = Quantity<i64, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for i128 {
    type Output = Quantity<i128, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for isize {
    type Output = Quantity<isize, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for u8 {
    type Output = Quantity<u8, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for u16 {
    type Output = Quantity<u16, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for u32 {
    type Output = Quantity<u32, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for u64 {
    type Output = Quantity<u64, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for u128 {
    type Output = Quantity<u128, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for usize {
    type Output = Quantity<usize, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for f32 {
    type Output = Quantity<f32, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
impl Mul<UnitKilomolesMul> for f64 {
    type Output = Quantity<f64, UnitKilomoles>;
    fn mul(self, _: UnitKilomolesMul) -> Self::Output {
        Quantity::new(self, UnitKilomoles)
    }
}
pub struct UnitHectomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectomoles {
    #[inline]
    fn clone(&self) -> UnitHectomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectomoles {
    #[inline]
    fn eq(&self, other: &UnitHectomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectomoles {
    fn default() -> Self {
        UnitHectomoles
    }
}
impl Add<UnitHectomoles> for UnitHectomoles {
    type Output = UnitHectomoles;
    #[inline]
    fn add(self, _: UnitHectomoles) -> Self::Output {
        UnitHectomoles
    }
}
impl AddAssign<UnitHectomoles> for UnitHectomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitHectomoles) {}
}
impl Sub<UnitHectomoles> for UnitHectomoles {
    type Output = UnitHectomoles;
    #[inline]
    fn sub(self, _: UnitHectomoles) -> Self::Output {
        UnitHectomoles
    }
}
impl SubAssign<UnitHectomoles> for UnitHectomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectomoles) {}
}
pub struct UnitHectomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectomolesMul {
    #[inline]
    fn clone(&self) -> UnitHectomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectomolesMul {
    #[inline]
    fn eq(&self, other: &UnitHectomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectomolesMul> for i8 {
    type Output = Quantity<i8, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for i16 {
    type Output = Quantity<i16, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for i32 {
    type Output = Quantity<i32, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for i64 {
    type Output = Quantity<i64, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for i128 {
    type Output = Quantity<i128, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for isize {
    type Output = Quantity<isize, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for u8 {
    type Output = Quantity<u8, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for u16 {
    type Output = Quantity<u16, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for u32 {
    type Output = Quantity<u32, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for u64 {
    type Output = Quantity<u64, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for u128 {
    type Output = Quantity<u128, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for usize {
    type Output = Quantity<usize, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for f32 {
    type Output = Quantity<f32, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
impl Mul<UnitHectomolesMul> for f64 {
    type Output = Quantity<f64, UnitHectomoles>;
    fn mul(self, _: UnitHectomolesMul) -> Self::Output {
        Quantity::new(self, UnitHectomoles)
    }
}
pub struct UnitDecamoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecamoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecamoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecamoles {
    #[inline]
    fn clone(&self) -> UnitDecamoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecamoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecamoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecamoles {
    #[inline]
    fn eq(&self, other: &UnitDecamoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecamoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecamoles {
    fn default() -> Self {
        UnitDecamoles
    }
}
impl Add<UnitDecamoles> for UnitDecamoles {
    type Output = UnitDecamoles;
    #[inline]
    fn add(self, _: UnitDecamoles) -> Self::Output {
        UnitDecamoles
    }
}
impl AddAssign<UnitDecamoles> for UnitDecamoles {
    #[inline]
    fn add_assign(&mut self, _: UnitDecamoles) {}
}
impl Sub<UnitDecamoles> for UnitDecamoles {
    type Output = UnitDecamoles;
    #[inline]
    fn sub(self, _: UnitDecamoles) -> Self::Output {
        UnitDecamoles
    }
}
impl SubAssign<UnitDecamoles> for UnitDecamoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecamoles) {}
}
pub struct UnitDecamolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecamolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecamolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecamolesMul {
    #[inline]
    fn clone(&self) -> UnitDecamolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecamolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecamolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecamolesMul {
    #[inline]
    fn eq(&self, other: &UnitDecamolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecamolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecamolesMul> for i8 {
    type Output = Quantity<i8, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for i16 {
    type Output = Quantity<i16, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for i32 {
    type Output = Quantity<i32, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for i64 {
    type Output = Quantity<i64, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for i128 {
    type Output = Quantity<i128, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for isize {
    type Output = Quantity<isize, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for u8 {
    type Output = Quantity<u8, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for u16 {
    type Output = Quantity<u16, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for u32 {
    type Output = Quantity<u32, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for u64 {
    type Output = Quantity<u64, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for u128 {
    type Output = Quantity<u128, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for usize {
    type Output = Quantity<usize, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for f32 {
    type Output = Quantity<f32, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
impl Mul<UnitDecamolesMul> for f64 {
    type Output = Quantity<f64, UnitDecamoles>;
    fn mul(self, _: UnitDecamolesMul) -> Self::Output {
        Quantity::new(self, UnitDecamoles)
    }
}
pub struct UnitDecimoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecimoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecimoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecimoles {
    #[inline]
    fn clone(&self) -> UnitDecimoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecimoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecimoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecimoles {
    #[inline]
    fn eq(&self, other: &UnitDecimoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecimoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecimoles {
    fn default() -> Self {
        UnitDecimoles
    }
}
impl Add<UnitDecimoles> for UnitDecimoles {
    type Output = UnitDecimoles;
    #[inline]
    fn add(self, _: UnitDecimoles) -> Self::Output {
        UnitDecimoles
    }
}
impl AddAssign<UnitDecimoles> for UnitDecimoles {
    #[inline]
    fn add_assign(&mut self, _: UnitDecimoles) {}
}
impl Sub<UnitDecimoles> for UnitDecimoles {
    type Output = UnitDecimoles;
    #[inline]
    fn sub(self, _: UnitDecimoles) -> Self::Output {
        UnitDecimoles
    }
}
impl SubAssign<UnitDecimoles> for UnitDecimoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecimoles) {}
}
pub struct UnitDecimolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecimolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecimolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecimolesMul {
    #[inline]
    fn clone(&self) -> UnitDecimolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecimolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecimolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecimolesMul {
    #[inline]
    fn eq(&self, other: &UnitDecimolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecimolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecimolesMul> for i8 {
    type Output = Quantity<i8, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for i16 {
    type Output = Quantity<i16, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for i32 {
    type Output = Quantity<i32, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for i64 {
    type Output = Quantity<i64, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for i128 {
    type Output = Quantity<i128, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for isize {
    type Output = Quantity<isize, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for u8 {
    type Output = Quantity<u8, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for u16 {
    type Output = Quantity<u16, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for u32 {
    type Output = Quantity<u32, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for u64 {
    type Output = Quantity<u64, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for u128 {
    type Output = Quantity<u128, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for usize {
    type Output = Quantity<usize, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for f32 {
    type Output = Quantity<f32, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
impl Mul<UnitDecimolesMul> for f64 {
    type Output = Quantity<f64, UnitDecimoles>;
    fn mul(self, _: UnitDecimolesMul) -> Self::Output {
        Quantity::new(self, UnitDecimoles)
    }
}
pub struct UnitCentimoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentimoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentimoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentimoles {
    #[inline]
    fn clone(&self) -> UnitCentimoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentimoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentimoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentimoles {
    #[inline]
    fn eq(&self, other: &UnitCentimoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentimoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentimoles {
    fn default() -> Self {
        UnitCentimoles
    }
}
impl Add<UnitCentimoles> for UnitCentimoles {
    type Output = UnitCentimoles;
    #[inline]
    fn add(self, _: UnitCentimoles) -> Self::Output {
        UnitCentimoles
    }
}
impl AddAssign<UnitCentimoles> for UnitCentimoles {
    #[inline]
    fn add_assign(&mut self, _: UnitCentimoles) {}
}
impl Sub<UnitCentimoles> for UnitCentimoles {
    type Output = UnitCentimoles;
    #[inline]
    fn sub(self, _: UnitCentimoles) -> Self::Output {
        UnitCentimoles
    }
}
impl SubAssign<UnitCentimoles> for UnitCentimoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentimoles) {}
}
pub struct UnitCentimolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentimolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentimolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentimolesMul {
    #[inline]
    fn clone(&self) -> UnitCentimolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentimolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentimolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentimolesMul {
    #[inline]
    fn eq(&self, other: &UnitCentimolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentimolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentimolesMul> for i8 {
    type Output = Quantity<i8, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for i16 {
    type Output = Quantity<i16, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for i32 {
    type Output = Quantity<i32, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for i64 {
    type Output = Quantity<i64, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for i128 {
    type Output = Quantity<i128, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for isize {
    type Output = Quantity<isize, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for u8 {
    type Output = Quantity<u8, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for u16 {
    type Output = Quantity<u16, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for u32 {
    type Output = Quantity<u32, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for u64 {
    type Output = Quantity<u64, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for u128 {
    type Output = Quantity<u128, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for usize {
    type Output = Quantity<usize, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for f32 {
    type Output = Quantity<f32, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
impl Mul<UnitCentimolesMul> for f64 {
    type Output = Quantity<f64, UnitCentimoles>;
    fn mul(self, _: UnitCentimolesMul) -> Self::Output {
        Quantity::new(self, UnitCentimoles)
    }
}
pub struct UnitMillimoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillimoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillimoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillimoles {
    #[inline]
    fn clone(&self) -> UnitMillimoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillimoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillimoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillimoles {
    #[inline]
    fn eq(&self, other: &UnitMillimoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillimoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillimoles {
    fn default() -> Self {
        UnitMillimoles
    }
}
impl Add<UnitMillimoles> for UnitMillimoles {
    type Output = UnitMillimoles;
    #[inline]
    fn add(self, _: UnitMillimoles) -> Self::Output {
        UnitMillimoles
    }
}
impl AddAssign<UnitMillimoles> for UnitMillimoles {
    #[inline]
    fn add_assign(&mut self, _: UnitMillimoles) {}
}
impl Sub<UnitMillimoles> for UnitMillimoles {
    type Output = UnitMillimoles;
    #[inline]
    fn sub(self, _: UnitMillimoles) -> Self::Output {
        UnitMillimoles
    }
}
impl SubAssign<UnitMillimoles> for UnitMillimoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillimoles) {}
}
pub struct UnitMillimolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillimolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillimolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillimolesMul {
    #[inline]
    fn clone(&self) -> UnitMillimolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillimolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillimolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillimolesMul {
    #[inline]
    fn eq(&self, other: &UnitMillimolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillimolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillimolesMul> for i8 {
    type Output = Quantity<i8, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for i16 {
    type Output = Quantity<i16, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for i32 {
    type Output = Quantity<i32, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for i64 {
    type Output = Quantity<i64, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for i128 {
    type Output = Quantity<i128, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for isize {
    type Output = Quantity<isize, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for u8 {
    type Output = Quantity<u8, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for u16 {
    type Output = Quantity<u16, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for u32 {
    type Output = Quantity<u32, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for u64 {
    type Output = Quantity<u64, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for u128 {
    type Output = Quantity<u128, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for usize {
    type Output = Quantity<usize, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for f32 {
    type Output = Quantity<f32, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
impl Mul<UnitMillimolesMul> for f64 {
    type Output = Quantity<f64, UnitMillimoles>;
    fn mul(self, _: UnitMillimolesMul) -> Self::Output {
        Quantity::new(self, UnitMillimoles)
    }
}
pub struct UnitMicromoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicromoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicromoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicromoles {
    #[inline]
    fn clone(&self) -> UnitMicromoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicromoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicromoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicromoles {
    #[inline]
    fn eq(&self, other: &UnitMicromoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicromoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicromoles {
    fn default() -> Self {
        UnitMicromoles
    }
}
impl Add<UnitMicromoles> for UnitMicromoles {
    type Output = UnitMicromoles;
    #[inline]
    fn add(self, _: UnitMicromoles) -> Self::Output {
        UnitMicromoles
    }
}
impl AddAssign<UnitMicromoles> for UnitMicromoles {
    #[inline]
    fn add_assign(&mut self, _: UnitMicromoles) {}
}
impl Sub<UnitMicromoles> for UnitMicromoles {
    type Output = UnitMicromoles;
    #[inline]
    fn sub(self, _: UnitMicromoles) -> Self::Output {
        UnitMicromoles
    }
}
impl SubAssign<UnitMicromoles> for UnitMicromoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicromoles) {}
}
pub struct UnitMicromolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicromolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicromolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicromolesMul {
    #[inline]
    fn clone(&self) -> UnitMicromolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicromolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicromolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicromolesMul {
    #[inline]
    fn eq(&self, other: &UnitMicromolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicromolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicromolesMul> for i8 {
    type Output = Quantity<i8, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for i16 {
    type Output = Quantity<i16, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for i32 {
    type Output = Quantity<i32, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for i64 {
    type Output = Quantity<i64, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for i128 {
    type Output = Quantity<i128, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for isize {
    type Output = Quantity<isize, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for u8 {
    type Output = Quantity<u8, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for u16 {
    type Output = Quantity<u16, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for u32 {
    type Output = Quantity<u32, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for u64 {
    type Output = Quantity<u64, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for u128 {
    type Output = Quantity<u128, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for usize {
    type Output = Quantity<usize, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for f32 {
    type Output = Quantity<f32, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
impl Mul<UnitMicromolesMul> for f64 {
    type Output = Quantity<f64, UnitMicromoles>;
    fn mul(self, _: UnitMicromolesMul) -> Self::Output {
        Quantity::new(self, UnitMicromoles)
    }
}
pub struct UnitNanomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanomoles {
    #[inline]
    fn clone(&self) -> UnitNanomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanomoles {
    #[inline]
    fn eq(&self, other: &UnitNanomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanomoles {
    fn default() -> Self {
        UnitNanomoles
    }
}
impl Add<UnitNanomoles> for UnitNanomoles {
    type Output = UnitNanomoles;
    #[inline]
    fn add(self, _: UnitNanomoles) -> Self::Output {
        UnitNanomoles
    }
}
impl AddAssign<UnitNanomoles> for UnitNanomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitNanomoles) {}
}
impl Sub<UnitNanomoles> for UnitNanomoles {
    type Output = UnitNanomoles;
    #[inline]
    fn sub(self, _: UnitNanomoles) -> Self::Output {
        UnitNanomoles
    }
}
impl SubAssign<UnitNanomoles> for UnitNanomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanomoles) {}
}
pub struct UnitNanomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanomolesMul {
    #[inline]
    fn clone(&self) -> UnitNanomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanomolesMul {
    #[inline]
    fn eq(&self, other: &UnitNanomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanomolesMul> for i8 {
    type Output = Quantity<i8, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for i16 {
    type Output = Quantity<i16, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for i32 {
    type Output = Quantity<i32, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for i64 {
    type Output = Quantity<i64, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for i128 {
    type Output = Quantity<i128, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for isize {
    type Output = Quantity<isize, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for u8 {
    type Output = Quantity<u8, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for u16 {
    type Output = Quantity<u16, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for u32 {
    type Output = Quantity<u32, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for u64 {
    type Output = Quantity<u64, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for u128 {
    type Output = Quantity<u128, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for usize {
    type Output = Quantity<usize, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for f32 {
    type Output = Quantity<f32, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
impl Mul<UnitNanomolesMul> for f64 {
    type Output = Quantity<f64, UnitNanomoles>;
    fn mul(self, _: UnitNanomolesMul) -> Self::Output {
        Quantity::new(self, UnitNanomoles)
    }
}
pub struct UnitPicomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicomoles {
    #[inline]
    fn clone(&self) -> UnitPicomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicomoles {
    #[inline]
    fn eq(&self, other: &UnitPicomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicomoles {
    fn default() -> Self {
        UnitPicomoles
    }
}
impl Add<UnitPicomoles> for UnitPicomoles {
    type Output = UnitPicomoles;
    #[inline]
    fn add(self, _: UnitPicomoles) -> Self::Output {
        UnitPicomoles
    }
}
impl AddAssign<UnitPicomoles> for UnitPicomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitPicomoles) {}
}
impl Sub<UnitPicomoles> for UnitPicomoles {
    type Output = UnitPicomoles;
    #[inline]
    fn sub(self, _: UnitPicomoles) -> Self::Output {
        UnitPicomoles
    }
}
impl SubAssign<UnitPicomoles> for UnitPicomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicomoles) {}
}
pub struct UnitPicomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicomolesMul {
    #[inline]
    fn clone(&self) -> UnitPicomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicomolesMul {
    #[inline]
    fn eq(&self, other: &UnitPicomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicomolesMul> for i8 {
    type Output = Quantity<i8, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for i16 {
    type Output = Quantity<i16, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for i32 {
    type Output = Quantity<i32, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for i64 {
    type Output = Quantity<i64, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for i128 {
    type Output = Quantity<i128, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for isize {
    type Output = Quantity<isize, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for u8 {
    type Output = Quantity<u8, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for u16 {
    type Output = Quantity<u16, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for u32 {
    type Output = Quantity<u32, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for u64 {
    type Output = Quantity<u64, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for u128 {
    type Output = Quantity<u128, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for usize {
    type Output = Quantity<usize, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for f32 {
    type Output = Quantity<f32, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
impl Mul<UnitPicomolesMul> for f64 {
    type Output = Quantity<f64, UnitPicomoles>;
    fn mul(self, _: UnitPicomolesMul) -> Self::Output {
        Quantity::new(self, UnitPicomoles)
    }
}
pub struct UnitFemtomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtomoles {
    #[inline]
    fn clone(&self) -> UnitFemtomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtomoles {
    #[inline]
    fn eq(&self, other: &UnitFemtomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtomoles {
    fn default() -> Self {
        UnitFemtomoles
    }
}
impl Add<UnitFemtomoles> for UnitFemtomoles {
    type Output = UnitFemtomoles;
    #[inline]
    fn add(self, _: UnitFemtomoles) -> Self::Output {
        UnitFemtomoles
    }
}
impl AddAssign<UnitFemtomoles> for UnitFemtomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtomoles) {}
}
impl Sub<UnitFemtomoles> for UnitFemtomoles {
    type Output = UnitFemtomoles;
    #[inline]
    fn sub(self, _: UnitFemtomoles) -> Self::Output {
        UnitFemtomoles
    }
}
impl SubAssign<UnitFemtomoles> for UnitFemtomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtomoles) {}
}
pub struct UnitFemtomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtomolesMul {
    #[inline]
    fn clone(&self) -> UnitFemtomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtomolesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtomolesMul> for i8 {
    type Output = Quantity<i8, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for i16 {
    type Output = Quantity<i16, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for i32 {
    type Output = Quantity<i32, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for i64 {
    type Output = Quantity<i64, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for i128 {
    type Output = Quantity<i128, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for isize {
    type Output = Quantity<isize, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for u8 {
    type Output = Quantity<u8, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for u16 {
    type Output = Quantity<u16, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for u32 {
    type Output = Quantity<u32, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for u64 {
    type Output = Quantity<u64, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for u128 {
    type Output = Quantity<u128, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for usize {
    type Output = Quantity<usize, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for f32 {
    type Output = Quantity<f32, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
impl Mul<UnitFemtomolesMul> for f64 {
    type Output = Quantity<f64, UnitFemtomoles>;
    fn mul(self, _: UnitFemtomolesMul) -> Self::Output {
        Quantity::new(self, UnitFemtomoles)
    }
}
pub struct UnitAttomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttomoles {
    #[inline]
    fn clone(&self) -> UnitAttomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttomoles {
    #[inline]
    fn eq(&self, other: &UnitAttomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttomoles {
    fn default() -> Self {
        UnitAttomoles
    }
}
impl Add<UnitAttomoles> for UnitAttomoles {
    type Output = UnitAttomoles;
    #[inline]
    fn add(self, _: UnitAttomoles) -> Self::Output {
        UnitAttomoles
    }
}
impl AddAssign<UnitAttomoles> for UnitAttomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitAttomoles) {}
}
impl Sub<UnitAttomoles> for UnitAttomoles {
    type Output = UnitAttomoles;
    #[inline]
    fn sub(self, _: UnitAttomoles) -> Self::Output {
        UnitAttomoles
    }
}
impl SubAssign<UnitAttomoles> for UnitAttomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttomoles) {}
}
pub struct UnitAttomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttomolesMul {
    #[inline]
    fn clone(&self) -> UnitAttomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttomolesMul {
    #[inline]
    fn eq(&self, other: &UnitAttomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttomolesMul> for i8 {
    type Output = Quantity<i8, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for i16 {
    type Output = Quantity<i16, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for i32 {
    type Output = Quantity<i32, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for i64 {
    type Output = Quantity<i64, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for i128 {
    type Output = Quantity<i128, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for isize {
    type Output = Quantity<isize, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for u8 {
    type Output = Quantity<u8, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for u16 {
    type Output = Quantity<u16, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for u32 {
    type Output = Quantity<u32, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for u64 {
    type Output = Quantity<u64, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for u128 {
    type Output = Quantity<u128, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for usize {
    type Output = Quantity<usize, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for f32 {
    type Output = Quantity<f32, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
impl Mul<UnitAttomolesMul> for f64 {
    type Output = Quantity<f64, UnitAttomoles>;
    fn mul(self, _: UnitAttomolesMul) -> Self::Output {
        Quantity::new(self, UnitAttomoles)
    }
}
pub struct UnitZeptomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptomoles {
    #[inline]
    fn clone(&self) -> UnitZeptomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptomoles {
    #[inline]
    fn eq(&self, other: &UnitZeptomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptomoles {
    fn default() -> Self {
        UnitZeptomoles
    }
}
impl Add<UnitZeptomoles> for UnitZeptomoles {
    type Output = UnitZeptomoles;
    #[inline]
    fn add(self, _: UnitZeptomoles) -> Self::Output {
        UnitZeptomoles
    }
}
impl AddAssign<UnitZeptomoles> for UnitZeptomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptomoles) {}
}
impl Sub<UnitZeptomoles> for UnitZeptomoles {
    type Output = UnitZeptomoles;
    #[inline]
    fn sub(self, _: UnitZeptomoles) -> Self::Output {
        UnitZeptomoles
    }
}
impl SubAssign<UnitZeptomoles> for UnitZeptomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptomoles) {}
}
pub struct UnitZeptomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptomolesMul {
    #[inline]
    fn clone(&self) -> UnitZeptomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptomolesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptomolesMul> for i8 {
    type Output = Quantity<i8, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for i16 {
    type Output = Quantity<i16, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for i32 {
    type Output = Quantity<i32, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for i64 {
    type Output = Quantity<i64, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for i128 {
    type Output = Quantity<i128, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for isize {
    type Output = Quantity<isize, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for u8 {
    type Output = Quantity<u8, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for u16 {
    type Output = Quantity<u16, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for u32 {
    type Output = Quantity<u32, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for u64 {
    type Output = Quantity<u64, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for u128 {
    type Output = Quantity<u128, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for usize {
    type Output = Quantity<usize, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for f32 {
    type Output = Quantity<f32, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
impl Mul<UnitZeptomolesMul> for f64 {
    type Output = Quantity<f64, UnitZeptomoles>;
    fn mul(self, _: UnitZeptomolesMul) -> Self::Output {
        Quantity::new(self, UnitZeptomoles)
    }
}
pub struct UnitYoctomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctomoles {
    #[inline]
    fn clone(&self) -> UnitYoctomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctomoles {
    #[inline]
    fn eq(&self, other: &UnitYoctomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctomoles {
    fn default() -> Self {
        UnitYoctomoles
    }
}
impl Add<UnitYoctomoles> for UnitYoctomoles {
    type Output = UnitYoctomoles;
    #[inline]
    fn add(self, _: UnitYoctomoles) -> Self::Output {
        UnitYoctomoles
    }
}
impl AddAssign<UnitYoctomoles> for UnitYoctomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctomoles) {}
}
impl Sub<UnitYoctomoles> for UnitYoctomoles {
    type Output = UnitYoctomoles;
    #[inline]
    fn sub(self, _: UnitYoctomoles) -> Self::Output {
        UnitYoctomoles
    }
}
impl SubAssign<UnitYoctomoles> for UnitYoctomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctomoles) {}
}
pub struct UnitYoctomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctomolesMul {
    #[inline]
    fn clone(&self) -> UnitYoctomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctomolesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctomolesMul> for i8 {
    type Output = Quantity<i8, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for i16 {
    type Output = Quantity<i16, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for i32 {
    type Output = Quantity<i32, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for i64 {
    type Output = Quantity<i64, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for i128 {
    type Output = Quantity<i128, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for isize {
    type Output = Quantity<isize, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for u8 {
    type Output = Quantity<u8, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for u16 {
    type Output = Quantity<u16, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for u32 {
    type Output = Quantity<u32, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for u64 {
    type Output = Quantity<u64, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for u128 {
    type Output = Quantity<u128, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for usize {
    type Output = Quantity<usize, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for f32 {
    type Output = Quantity<f32, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
impl Mul<UnitYoctomolesMul> for f64 {
    type Output = Quantity<f64, UnitYoctomoles>;
    fn mul(self, _: UnitYoctomolesMul) -> Self::Output {
        Quantity::new(self, UnitYoctomoles)
    }
}
pub struct UnitRontomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontomoles {
    #[inline]
    fn clone(&self) -> UnitRontomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontomoles {
    #[inline]
    fn eq(&self, other: &UnitRontomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontomoles {
    fn default() -> Self {
        UnitRontomoles
    }
}
impl Add<UnitRontomoles> for UnitRontomoles {
    type Output = UnitRontomoles;
    #[inline]
    fn add(self, _: UnitRontomoles) -> Self::Output {
        UnitRontomoles
    }
}
impl AddAssign<UnitRontomoles> for UnitRontomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitRontomoles) {}
}
impl Sub<UnitRontomoles> for UnitRontomoles {
    type Output = UnitRontomoles;
    #[inline]
    fn sub(self, _: UnitRontomoles) -> Self::Output {
        UnitRontomoles
    }
}
impl SubAssign<UnitRontomoles> for UnitRontomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontomoles) {}
}
pub struct UnitRontomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontomolesMul {
    #[inline]
    fn clone(&self) -> UnitRontomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontomolesMul {
    #[inline]
    fn eq(&self, other: &UnitRontomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontomolesMul> for i8 {
    type Output = Quantity<i8, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for i16 {
    type Output = Quantity<i16, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for i32 {
    type Output = Quantity<i32, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for i64 {
    type Output = Quantity<i64, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for i128 {
    type Output = Quantity<i128, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for isize {
    type Output = Quantity<isize, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for u8 {
    type Output = Quantity<u8, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for u16 {
    type Output = Quantity<u16, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for u32 {
    type Output = Quantity<u32, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for u64 {
    type Output = Quantity<u64, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for u128 {
    type Output = Quantity<u128, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for usize {
    type Output = Quantity<usize, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for f32 {
    type Output = Quantity<f32, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
impl Mul<UnitRontomolesMul> for f64 {
    type Output = Quantity<f64, UnitRontomoles>;
    fn mul(self, _: UnitRontomolesMul) -> Self::Output {
        Quantity::new(self, UnitRontomoles)
    }
}
pub struct UnitQuectomoles;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectomoles {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectomoles")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectomoles {
    #[inline]
    fn clone(&self) -> UnitQuectomoles {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectomoles {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectomoles {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectomoles {
    #[inline]
    fn eq(&self, other: &UnitQuectomoles) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectomoles {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectomoles {
    fn default() -> Self {
        UnitQuectomoles
    }
}
impl Add<UnitQuectomoles> for UnitQuectomoles {
    type Output = UnitQuectomoles;
    #[inline]
    fn add(self, _: UnitQuectomoles) -> Self::Output {
        UnitQuectomoles
    }
}
impl AddAssign<UnitQuectomoles> for UnitQuectomoles {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectomoles) {}
}
impl Sub<UnitQuectomoles> for UnitQuectomoles {
    type Output = UnitQuectomoles;
    #[inline]
    fn sub(self, _: UnitQuectomoles) -> Self::Output {
        UnitQuectomoles
    }
}
impl SubAssign<UnitQuectomoles> for UnitQuectomoles {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectomoles) {}
}
pub struct UnitQuectomolesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectomolesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectomolesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectomolesMul {
    #[inline]
    fn clone(&self) -> UnitQuectomolesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectomolesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectomolesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectomolesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectomolesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectomolesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectomolesMul> for i8 {
    type Output = Quantity<i8, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for i16 {
    type Output = Quantity<i16, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for i32 {
    type Output = Quantity<i32, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for i64 {
    type Output = Quantity<i64, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for i128 {
    type Output = Quantity<i128, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for isize {
    type Output = Quantity<isize, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for u8 {
    type Output = Quantity<u8, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for u16 {
    type Output = Quantity<u16, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for u32 {
    type Output = Quantity<u32, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for u64 {
    type Output = Quantity<u64, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for u128 {
    type Output = Quantity<u128, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for usize {
    type Output = Quantity<usize, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for f32 {
    type Output = Quantity<f32, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
impl Mul<UnitQuectomolesMul> for f64 {
    type Output = Quantity<f64, UnitQuectomoles>;
    fn mul(self, _: UnitQuectomolesMul) -> Self::Output {
        Quantity::new(self, UnitQuectomoles)
    }
}
pub type Moles<T> = Quantity<T, UnitMoles>;
#[allow(non_upper_case_globals)]
pub static Moles: UnitMolesMul = UnitMolesMul;
pub type Quettamoles<T> = Quantity<T, UnitQuettamoles>;
#[allow(non_upper_case_globals)]
pub static Quettamoles: UnitQuettamolesMul = UnitQuettamolesMul;
pub type Ronnamoles<T> = Quantity<T, UnitRonnamoles>;
#[allow(non_upper_case_globals)]
pub static Ronnamoles: UnitRonnamolesMul = UnitRonnamolesMul;
pub type Yottamoles<T> = Quantity<T, UnitYottamoles>;
#[allow(non_upper_case_globals)]
pub static Yottamoles: UnitYottamolesMul = UnitYottamolesMul;
pub type Zettamoles<T> = Quantity<T, UnitZettamoles>;
#[allow(non_upper_case_globals)]
pub static Zettamoles: UnitZettamolesMul = UnitZettamolesMul;
pub type Examoles<T> = Quantity<T, UnitExamoles>;
#[allow(non_upper_case_globals)]
pub static Examoles: UnitExamolesMul = UnitExamolesMul;
pub type Petamoles<T> = Quantity<T, UnitPetamoles>;
#[allow(non_upper_case_globals)]
pub static Petamoles: UnitPetamolesMul = UnitPetamolesMul;
pub type Teramoles<T> = Quantity<T, UnitTeramoles>;
#[allow(non_upper_case_globals)]
pub static Teramoles: UnitTeramolesMul = UnitTeramolesMul;
pub type Gigamoles<T> = Quantity<T, UnitGigamoles>;
#[allow(non_upper_case_globals)]
pub static Gigamoles: UnitGigamolesMul = UnitGigamolesMul;
pub type Megamoles<T> = Quantity<T, UnitMegamoles>;
#[allow(non_upper_case_globals)]
pub static Megamoles: UnitMegamolesMul = UnitMegamolesMul;
pub type Kilomoles<T> = Quantity<T, UnitKilomoles>;
#[allow(non_upper_case_globals)]
pub static Kilomoles: UnitKilomolesMul = UnitKilomolesMul;
pub type Hectomoles<T> = Quantity<T, UnitHectomoles>;
#[allow(non_upper_case_globals)]
pub static Hectomoles: UnitHectomolesMul = UnitHectomolesMul;
pub type Decamoles<T> = Quantity<T, UnitDecamoles>;
#[allow(non_upper_case_globals)]
pub static Decamoles: UnitDecamolesMul = UnitDecamolesMul;
pub type Decimoles<T> = Quantity<T, UnitDecimoles>;
#[allow(non_upper_case_globals)]
pub static Decimoles: UnitDecimolesMul = UnitDecimolesMul;
pub type Centimoles<T> = Quantity<T, UnitCentimoles>;
#[allow(non_upper_case_globals)]
pub static Centimoles: UnitCentimolesMul = UnitCentimolesMul;
pub type Millimoles<T> = Quantity<T, UnitMillimoles>;
#[allow(non_upper_case_globals)]
pub static Millimoles: UnitMillimolesMul = UnitMillimolesMul;
pub type Micromoles<T> = Quantity<T, UnitMicromoles>;
#[allow(non_upper_case_globals)]
pub static Micromoles: UnitMicromolesMul = UnitMicromolesMul;
pub type Nanomoles<T> = Quantity<T, UnitNanomoles>;
#[allow(non_upper_case_globals)]
pub static Nanomoles: UnitNanomolesMul = UnitNanomolesMul;
pub type Picomoles<T> = Quantity<T, UnitPicomoles>;
#[allow(non_upper_case_globals)]
pub static Picomoles: UnitPicomolesMul = UnitPicomolesMul;
pub type Femtomoles<T> = Quantity<T, UnitFemtomoles>;
#[allow(non_upper_case_globals)]
pub static Femtomoles: UnitFemtomolesMul = UnitFemtomolesMul;
pub type Attomoles<T> = Quantity<T, UnitAttomoles>;
#[allow(non_upper_case_globals)]
pub static Attomoles: UnitAttomolesMul = UnitAttomolesMul;
pub type Zeptomoles<T> = Quantity<T, UnitZeptomoles>;
#[allow(non_upper_case_globals)]
pub static Zeptomoles: UnitZeptomolesMul = UnitZeptomolesMul;
pub type Yoctomoles<T> = Quantity<T, UnitYoctomoles>;
#[allow(non_upper_case_globals)]
pub static Yoctomoles: UnitYoctomolesMul = UnitYoctomolesMul;
pub type Rontomoles<T> = Quantity<T, UnitRontomoles>;
#[allow(non_upper_case_globals)]
pub static Rontomoles: UnitRontomolesMul = UnitRontomolesMul;
pub type Quectomoles<T> = Quantity<T, UnitQuectomoles>;
#[allow(non_upper_case_globals)]
pub static Quectomoles: UnitQuectomolesMul = UnitQuectomolesMul;
pub struct UnitCandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCandelas {
    #[inline]
    fn clone(&self) -> UnitCandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCandelas {
    #[inline]
    fn eq(&self, other: &UnitCandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCandelas {
    fn default() -> Self {
        UnitCandelas
    }
}
impl Add<UnitCandelas> for UnitCandelas {
    type Output = UnitCandelas;
    #[inline]
    fn add(self, _: UnitCandelas) -> Self::Output {
        UnitCandelas
    }
}
impl AddAssign<UnitCandelas> for UnitCandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitCandelas) {}
}
impl Sub<UnitCandelas> for UnitCandelas {
    type Output = UnitCandelas;
    #[inline]
    fn sub(self, _: UnitCandelas) -> Self::Output {
        UnitCandelas
    }
}
impl SubAssign<UnitCandelas> for UnitCandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitCandelas) {}
}
pub struct UnitCandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCandelasMul {
    #[inline]
    fn clone(&self) -> UnitCandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCandelasMul {
    #[inline]
    fn eq(&self, other: &UnitCandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCandelasMul> for i8 {
    type Output = Quantity<i8, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for i16 {
    type Output = Quantity<i16, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for i32 {
    type Output = Quantity<i32, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for i64 {
    type Output = Quantity<i64, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for i128 {
    type Output = Quantity<i128, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for isize {
    type Output = Quantity<isize, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for u8 {
    type Output = Quantity<u8, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for u16 {
    type Output = Quantity<u16, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for u32 {
    type Output = Quantity<u32, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for u64 {
    type Output = Quantity<u64, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for u128 {
    type Output = Quantity<u128, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for usize {
    type Output = Quantity<usize, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for f32 {
    type Output = Quantity<f32, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
impl Mul<UnitCandelasMul> for f64 {
    type Output = Quantity<f64, UnitCandelas>;
    fn mul(self, _: UnitCandelasMul) -> Self::Output {
        Quantity::new(self, UnitCandelas)
    }
}
pub struct UnitQuettacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacandelas {
    #[inline]
    fn clone(&self) -> UnitQuettacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacandelas {
    #[inline]
    fn eq(&self, other: &UnitQuettacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettacandelas {
    fn default() -> Self {
        UnitQuettacandelas
    }
}
impl Add<UnitQuettacandelas> for UnitQuettacandelas {
    type Output = UnitQuettacandelas;
    #[inline]
    fn add(self, _: UnitQuettacandelas) -> Self::Output {
        UnitQuettacandelas
    }
}
impl AddAssign<UnitQuettacandelas> for UnitQuettacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettacandelas) {}
}
impl Sub<UnitQuettacandelas> for UnitQuettacandelas {
    type Output = UnitQuettacandelas;
    #[inline]
    fn sub(self, _: UnitQuettacandelas) -> Self::Output {
        UnitQuettacandelas
    }
}
impl SubAssign<UnitQuettacandelas> for UnitQuettacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettacandelas) {}
}
pub struct UnitQuettacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacandelasMul {
    #[inline]
    fn clone(&self) -> UnitQuettacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitQuettacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettacandelasMul> for i8 {
    type Output = Quantity<i8, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for i16 {
    type Output = Quantity<i16, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for i32 {
    type Output = Quantity<i32, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for i64 {
    type Output = Quantity<i64, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for i128 {
    type Output = Quantity<i128, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for isize {
    type Output = Quantity<isize, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for u8 {
    type Output = Quantity<u8, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for u16 {
    type Output = Quantity<u16, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for u32 {
    type Output = Quantity<u32, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for u64 {
    type Output = Quantity<u64, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for u128 {
    type Output = Quantity<u128, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for usize {
    type Output = Quantity<usize, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for f32 {
    type Output = Quantity<f32, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
impl Mul<UnitQuettacandelasMul> for f64 {
    type Output = Quantity<f64, UnitQuettacandelas>;
    fn mul(self, _: UnitQuettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuettacandelas)
    }
}
pub struct UnitRonnacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacandelas {
    #[inline]
    fn clone(&self) -> UnitRonnacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacandelas {
    #[inline]
    fn eq(&self, other: &UnitRonnacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnacandelas {
    fn default() -> Self {
        UnitRonnacandelas
    }
}
impl Add<UnitRonnacandelas> for UnitRonnacandelas {
    type Output = UnitRonnacandelas;
    #[inline]
    fn add(self, _: UnitRonnacandelas) -> Self::Output {
        UnitRonnacandelas
    }
}
impl AddAssign<UnitRonnacandelas> for UnitRonnacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnacandelas) {}
}
impl Sub<UnitRonnacandelas> for UnitRonnacandelas {
    type Output = UnitRonnacandelas;
    #[inline]
    fn sub(self, _: UnitRonnacandelas) -> Self::Output {
        UnitRonnacandelas
    }
}
impl SubAssign<UnitRonnacandelas> for UnitRonnacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnacandelas) {}
}
pub struct UnitRonnacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacandelasMul {
    #[inline]
    fn clone(&self) -> UnitRonnacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitRonnacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnacandelasMul> for i8 {
    type Output = Quantity<i8, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for i16 {
    type Output = Quantity<i16, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for i32 {
    type Output = Quantity<i32, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for i64 {
    type Output = Quantity<i64, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for i128 {
    type Output = Quantity<i128, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for isize {
    type Output = Quantity<isize, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for u8 {
    type Output = Quantity<u8, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for u16 {
    type Output = Quantity<u16, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for u32 {
    type Output = Quantity<u32, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for u64 {
    type Output = Quantity<u64, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for u128 {
    type Output = Quantity<u128, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for usize {
    type Output = Quantity<usize, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for f32 {
    type Output = Quantity<f32, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
impl Mul<UnitRonnacandelasMul> for f64 {
    type Output = Quantity<f64, UnitRonnacandelas>;
    fn mul(self, _: UnitRonnacandelasMul) -> Self::Output {
        Quantity::new(self, UnitRonnacandelas)
    }
}
pub struct UnitYottacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacandelas {
    #[inline]
    fn clone(&self) -> UnitYottacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacandelas {
    #[inline]
    fn eq(&self, other: &UnitYottacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottacandelas {
    fn default() -> Self {
        UnitYottacandelas
    }
}
impl Add<UnitYottacandelas> for UnitYottacandelas {
    type Output = UnitYottacandelas;
    #[inline]
    fn add(self, _: UnitYottacandelas) -> Self::Output {
        UnitYottacandelas
    }
}
impl AddAssign<UnitYottacandelas> for UnitYottacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitYottacandelas) {}
}
impl Sub<UnitYottacandelas> for UnitYottacandelas {
    type Output = UnitYottacandelas;
    #[inline]
    fn sub(self, _: UnitYottacandelas) -> Self::Output {
        UnitYottacandelas
    }
}
impl SubAssign<UnitYottacandelas> for UnitYottacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottacandelas) {}
}
pub struct UnitYottacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacandelasMul {
    #[inline]
    fn clone(&self) -> UnitYottacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitYottacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottacandelasMul> for i8 {
    type Output = Quantity<i8, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for i16 {
    type Output = Quantity<i16, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for i32 {
    type Output = Quantity<i32, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for i64 {
    type Output = Quantity<i64, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for i128 {
    type Output = Quantity<i128, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for isize {
    type Output = Quantity<isize, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for u8 {
    type Output = Quantity<u8, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for u16 {
    type Output = Quantity<u16, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for u32 {
    type Output = Quantity<u32, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for u64 {
    type Output = Quantity<u64, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for u128 {
    type Output = Quantity<u128, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for usize {
    type Output = Quantity<usize, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for f32 {
    type Output = Quantity<f32, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
impl Mul<UnitYottacandelasMul> for f64 {
    type Output = Quantity<f64, UnitYottacandelas>;
    fn mul(self, _: UnitYottacandelasMul) -> Self::Output {
        Quantity::new(self, UnitYottacandelas)
    }
}
pub struct UnitZettacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacandelas {
    #[inline]
    fn clone(&self) -> UnitZettacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacandelas {
    #[inline]
    fn eq(&self, other: &UnitZettacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettacandelas {
    fn default() -> Self {
        UnitZettacandelas
    }
}
impl Add<UnitZettacandelas> for UnitZettacandelas {
    type Output = UnitZettacandelas;
    #[inline]
    fn add(self, _: UnitZettacandelas) -> Self::Output {
        UnitZettacandelas
    }
}
impl AddAssign<UnitZettacandelas> for UnitZettacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitZettacandelas) {}
}
impl Sub<UnitZettacandelas> for UnitZettacandelas {
    type Output = UnitZettacandelas;
    #[inline]
    fn sub(self, _: UnitZettacandelas) -> Self::Output {
        UnitZettacandelas
    }
}
impl SubAssign<UnitZettacandelas> for UnitZettacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettacandelas) {}
}
pub struct UnitZettacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacandelasMul {
    #[inline]
    fn clone(&self) -> UnitZettacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitZettacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettacandelasMul> for i8 {
    type Output = Quantity<i8, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for i16 {
    type Output = Quantity<i16, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for i32 {
    type Output = Quantity<i32, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for i64 {
    type Output = Quantity<i64, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for i128 {
    type Output = Quantity<i128, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for isize {
    type Output = Quantity<isize, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for u8 {
    type Output = Quantity<u8, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for u16 {
    type Output = Quantity<u16, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for u32 {
    type Output = Quantity<u32, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for u64 {
    type Output = Quantity<u64, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for u128 {
    type Output = Quantity<u128, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for usize {
    type Output = Quantity<usize, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for f32 {
    type Output = Quantity<f32, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
impl Mul<UnitZettacandelasMul> for f64 {
    type Output = Quantity<f64, UnitZettacandelas>;
    fn mul(self, _: UnitZettacandelasMul) -> Self::Output {
        Quantity::new(self, UnitZettacandelas)
    }
}
pub struct UnitExacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacandelas {
    #[inline]
    fn clone(&self) -> UnitExacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacandelas {
    #[inline]
    fn eq(&self, other: &UnitExacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExacandelas {
    fn default() -> Self {
        UnitExacandelas
    }
}
impl Add<UnitExacandelas> for UnitExacandelas {
    type Output = UnitExacandelas;
    #[inline]
    fn add(self, _: UnitExacandelas) -> Self::Output {
        UnitExacandelas
    }
}
impl AddAssign<UnitExacandelas> for UnitExacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitExacandelas) {}
}
impl Sub<UnitExacandelas> for UnitExacandelas {
    type Output = UnitExacandelas;
    #[inline]
    fn sub(self, _: UnitExacandelas) -> Self::Output {
        UnitExacandelas
    }
}
impl SubAssign<UnitExacandelas> for UnitExacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitExacandelas) {}
}
pub struct UnitExacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacandelasMul {
    #[inline]
    fn clone(&self) -> UnitExacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitExacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExacandelasMul> for i8 {
    type Output = Quantity<i8, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for i16 {
    type Output = Quantity<i16, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for i32 {
    type Output = Quantity<i32, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for i64 {
    type Output = Quantity<i64, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for i128 {
    type Output = Quantity<i128, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for isize {
    type Output = Quantity<isize, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for u8 {
    type Output = Quantity<u8, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for u16 {
    type Output = Quantity<u16, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for u32 {
    type Output = Quantity<u32, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for u64 {
    type Output = Quantity<u64, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for u128 {
    type Output = Quantity<u128, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for usize {
    type Output = Quantity<usize, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for f32 {
    type Output = Quantity<f32, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
impl Mul<UnitExacandelasMul> for f64 {
    type Output = Quantity<f64, UnitExacandelas>;
    fn mul(self, _: UnitExacandelasMul) -> Self::Output {
        Quantity::new(self, UnitExacandelas)
    }
}
pub struct UnitPetacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacandelas {
    #[inline]
    fn clone(&self) -> UnitPetacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacandelas {
    #[inline]
    fn eq(&self, other: &UnitPetacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetacandelas {
    fn default() -> Self {
        UnitPetacandelas
    }
}
impl Add<UnitPetacandelas> for UnitPetacandelas {
    type Output = UnitPetacandelas;
    #[inline]
    fn add(self, _: UnitPetacandelas) -> Self::Output {
        UnitPetacandelas
    }
}
impl AddAssign<UnitPetacandelas> for UnitPetacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitPetacandelas) {}
}
impl Sub<UnitPetacandelas> for UnitPetacandelas {
    type Output = UnitPetacandelas;
    #[inline]
    fn sub(self, _: UnitPetacandelas) -> Self::Output {
        UnitPetacandelas
    }
}
impl SubAssign<UnitPetacandelas> for UnitPetacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetacandelas) {}
}
pub struct UnitPetacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacandelasMul {
    #[inline]
    fn clone(&self) -> UnitPetacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitPetacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetacandelasMul> for i8 {
    type Output = Quantity<i8, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for i16 {
    type Output = Quantity<i16, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for i32 {
    type Output = Quantity<i32, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for i64 {
    type Output = Quantity<i64, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for i128 {
    type Output = Quantity<i128, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for isize {
    type Output = Quantity<isize, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for u8 {
    type Output = Quantity<u8, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for u16 {
    type Output = Quantity<u16, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for u32 {
    type Output = Quantity<u32, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for u64 {
    type Output = Quantity<u64, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for u128 {
    type Output = Quantity<u128, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for usize {
    type Output = Quantity<usize, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for f32 {
    type Output = Quantity<f32, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
impl Mul<UnitPetacandelasMul> for f64 {
    type Output = Quantity<f64, UnitPetacandelas>;
    fn mul(self, _: UnitPetacandelasMul) -> Self::Output {
        Quantity::new(self, UnitPetacandelas)
    }
}
pub struct UnitTeracandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracandelas {
    #[inline]
    fn clone(&self) -> UnitTeracandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracandelas {
    #[inline]
    fn eq(&self, other: &UnitTeracandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeracandelas {
    fn default() -> Self {
        UnitTeracandelas
    }
}
impl Add<UnitTeracandelas> for UnitTeracandelas {
    type Output = UnitTeracandelas;
    #[inline]
    fn add(self, _: UnitTeracandelas) -> Self::Output {
        UnitTeracandelas
    }
}
impl AddAssign<UnitTeracandelas> for UnitTeracandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitTeracandelas) {}
}
impl Sub<UnitTeracandelas> for UnitTeracandelas {
    type Output = UnitTeracandelas;
    #[inline]
    fn sub(self, _: UnitTeracandelas) -> Self::Output {
        UnitTeracandelas
    }
}
impl SubAssign<UnitTeracandelas> for UnitTeracandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeracandelas) {}
}
pub struct UnitTeracandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracandelasMul {
    #[inline]
    fn clone(&self) -> UnitTeracandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracandelasMul {
    #[inline]
    fn eq(&self, other: &UnitTeracandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeracandelasMul> for i8 {
    type Output = Quantity<i8, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for i16 {
    type Output = Quantity<i16, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for i32 {
    type Output = Quantity<i32, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for i64 {
    type Output = Quantity<i64, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for i128 {
    type Output = Quantity<i128, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for isize {
    type Output = Quantity<isize, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for u8 {
    type Output = Quantity<u8, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for u16 {
    type Output = Quantity<u16, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for u32 {
    type Output = Quantity<u32, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for u64 {
    type Output = Quantity<u64, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for u128 {
    type Output = Quantity<u128, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for usize {
    type Output = Quantity<usize, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for f32 {
    type Output = Quantity<f32, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
impl Mul<UnitTeracandelasMul> for f64 {
    type Output = Quantity<f64, UnitTeracandelas>;
    fn mul(self, _: UnitTeracandelasMul) -> Self::Output {
        Quantity::new(self, UnitTeracandelas)
    }
}
pub struct UnitGigacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacandelas {
    #[inline]
    fn clone(&self) -> UnitGigacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacandelas {
    #[inline]
    fn eq(&self, other: &UnitGigacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigacandelas {
    fn default() -> Self {
        UnitGigacandelas
    }
}
impl Add<UnitGigacandelas> for UnitGigacandelas {
    type Output = UnitGigacandelas;
    #[inline]
    fn add(self, _: UnitGigacandelas) -> Self::Output {
        UnitGigacandelas
    }
}
impl AddAssign<UnitGigacandelas> for UnitGigacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitGigacandelas) {}
}
impl Sub<UnitGigacandelas> for UnitGigacandelas {
    type Output = UnitGigacandelas;
    #[inline]
    fn sub(self, _: UnitGigacandelas) -> Self::Output {
        UnitGigacandelas
    }
}
impl SubAssign<UnitGigacandelas> for UnitGigacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigacandelas) {}
}
pub struct UnitGigacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacandelasMul {
    #[inline]
    fn clone(&self) -> UnitGigacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitGigacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigacandelasMul> for i8 {
    type Output = Quantity<i8, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for i16 {
    type Output = Quantity<i16, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for i32 {
    type Output = Quantity<i32, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for i64 {
    type Output = Quantity<i64, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for i128 {
    type Output = Quantity<i128, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for isize {
    type Output = Quantity<isize, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for u8 {
    type Output = Quantity<u8, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for u16 {
    type Output = Quantity<u16, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for u32 {
    type Output = Quantity<u32, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for u64 {
    type Output = Quantity<u64, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for u128 {
    type Output = Quantity<u128, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for usize {
    type Output = Quantity<usize, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for f32 {
    type Output = Quantity<f32, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
impl Mul<UnitGigacandelasMul> for f64 {
    type Output = Quantity<f64, UnitGigacandelas>;
    fn mul(self, _: UnitGigacandelasMul) -> Self::Output {
        Quantity::new(self, UnitGigacandelas)
    }
}
pub struct UnitMegacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacandelas {
    #[inline]
    fn clone(&self) -> UnitMegacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacandelas {
    #[inline]
    fn eq(&self, other: &UnitMegacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegacandelas {
    fn default() -> Self {
        UnitMegacandelas
    }
}
impl Add<UnitMegacandelas> for UnitMegacandelas {
    type Output = UnitMegacandelas;
    #[inline]
    fn add(self, _: UnitMegacandelas) -> Self::Output {
        UnitMegacandelas
    }
}
impl AddAssign<UnitMegacandelas> for UnitMegacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitMegacandelas) {}
}
impl Sub<UnitMegacandelas> for UnitMegacandelas {
    type Output = UnitMegacandelas;
    #[inline]
    fn sub(self, _: UnitMegacandelas) -> Self::Output {
        UnitMegacandelas
    }
}
impl SubAssign<UnitMegacandelas> for UnitMegacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegacandelas) {}
}
pub struct UnitMegacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacandelasMul {
    #[inline]
    fn clone(&self) -> UnitMegacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitMegacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegacandelasMul> for i8 {
    type Output = Quantity<i8, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for i16 {
    type Output = Quantity<i16, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for i32 {
    type Output = Quantity<i32, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for i64 {
    type Output = Quantity<i64, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for i128 {
    type Output = Quantity<i128, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for isize {
    type Output = Quantity<isize, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for u8 {
    type Output = Quantity<u8, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for u16 {
    type Output = Quantity<u16, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for u32 {
    type Output = Quantity<u32, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for u64 {
    type Output = Quantity<u64, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for u128 {
    type Output = Quantity<u128, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for usize {
    type Output = Quantity<usize, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for f32 {
    type Output = Quantity<f32, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
impl Mul<UnitMegacandelasMul> for f64 {
    type Output = Quantity<f64, UnitMegacandelas>;
    fn mul(self, _: UnitMegacandelasMul) -> Self::Output {
        Quantity::new(self, UnitMegacandelas)
    }
}
pub struct UnitKilocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocandelas {
    #[inline]
    fn clone(&self) -> UnitKilocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocandelas {
    #[inline]
    fn eq(&self, other: &UnitKilocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilocandelas {
    fn default() -> Self {
        UnitKilocandelas
    }
}
impl Add<UnitKilocandelas> for UnitKilocandelas {
    type Output = UnitKilocandelas;
    #[inline]
    fn add(self, _: UnitKilocandelas) -> Self::Output {
        UnitKilocandelas
    }
}
impl AddAssign<UnitKilocandelas> for UnitKilocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitKilocandelas) {}
}
impl Sub<UnitKilocandelas> for UnitKilocandelas {
    type Output = UnitKilocandelas;
    #[inline]
    fn sub(self, _: UnitKilocandelas) -> Self::Output {
        UnitKilocandelas
    }
}
impl SubAssign<UnitKilocandelas> for UnitKilocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilocandelas) {}
}
pub struct UnitKilocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocandelasMul {
    #[inline]
    fn clone(&self) -> UnitKilocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitKilocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilocandelasMul> for i8 {
    type Output = Quantity<i8, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for i16 {
    type Output = Quantity<i16, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for i32 {
    type Output = Quantity<i32, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for i64 {
    type Output = Quantity<i64, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for i128 {
    type Output = Quantity<i128, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for isize {
    type Output = Quantity<isize, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for u8 {
    type Output = Quantity<u8, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for u16 {
    type Output = Quantity<u16, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for u32 {
    type Output = Quantity<u32, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for u64 {
    type Output = Quantity<u64, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for u128 {
    type Output = Quantity<u128, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for usize {
    type Output = Quantity<usize, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for f32 {
    type Output = Quantity<f32, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
impl Mul<UnitKilocandelasMul> for f64 {
    type Output = Quantity<f64, UnitKilocandelas>;
    fn mul(self, _: UnitKilocandelasMul) -> Self::Output {
        Quantity::new(self, UnitKilocandelas)
    }
}
pub struct UnitHectocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocandelas {
    #[inline]
    fn clone(&self) -> UnitHectocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocandelas {
    #[inline]
    fn eq(&self, other: &UnitHectocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectocandelas {
    fn default() -> Self {
        UnitHectocandelas
    }
}
impl Add<UnitHectocandelas> for UnitHectocandelas {
    type Output = UnitHectocandelas;
    #[inline]
    fn add(self, _: UnitHectocandelas) -> Self::Output {
        UnitHectocandelas
    }
}
impl AddAssign<UnitHectocandelas> for UnitHectocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitHectocandelas) {}
}
impl Sub<UnitHectocandelas> for UnitHectocandelas {
    type Output = UnitHectocandelas;
    #[inline]
    fn sub(self, _: UnitHectocandelas) -> Self::Output {
        UnitHectocandelas
    }
}
impl SubAssign<UnitHectocandelas> for UnitHectocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectocandelas) {}
}
pub struct UnitHectocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocandelasMul {
    #[inline]
    fn clone(&self) -> UnitHectocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitHectocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectocandelasMul> for i8 {
    type Output = Quantity<i8, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for i16 {
    type Output = Quantity<i16, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for i32 {
    type Output = Quantity<i32, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for i64 {
    type Output = Quantity<i64, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for i128 {
    type Output = Quantity<i128, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for isize {
    type Output = Quantity<isize, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for u8 {
    type Output = Quantity<u8, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for u16 {
    type Output = Quantity<u16, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for u32 {
    type Output = Quantity<u32, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for u64 {
    type Output = Quantity<u64, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for u128 {
    type Output = Quantity<u128, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for usize {
    type Output = Quantity<usize, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for f32 {
    type Output = Quantity<f32, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
impl Mul<UnitHectocandelasMul> for f64 {
    type Output = Quantity<f64, UnitHectocandelas>;
    fn mul(self, _: UnitHectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitHectocandelas)
    }
}
pub struct UnitDecacandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacandelas {
    #[inline]
    fn clone(&self) -> UnitDecacandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacandelas {
    #[inline]
    fn eq(&self, other: &UnitDecacandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecacandelas {
    fn default() -> Self {
        UnitDecacandelas
    }
}
impl Add<UnitDecacandelas> for UnitDecacandelas {
    type Output = UnitDecacandelas;
    #[inline]
    fn add(self, _: UnitDecacandelas) -> Self::Output {
        UnitDecacandelas
    }
}
impl AddAssign<UnitDecacandelas> for UnitDecacandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitDecacandelas) {}
}
impl Sub<UnitDecacandelas> for UnitDecacandelas {
    type Output = UnitDecacandelas;
    #[inline]
    fn sub(self, _: UnitDecacandelas) -> Self::Output {
        UnitDecacandelas
    }
}
impl SubAssign<UnitDecacandelas> for UnitDecacandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecacandelas) {}
}
pub struct UnitDecacandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacandelasMul {
    #[inline]
    fn clone(&self) -> UnitDecacandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacandelasMul {
    #[inline]
    fn eq(&self, other: &UnitDecacandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecacandelasMul> for i8 {
    type Output = Quantity<i8, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for i16 {
    type Output = Quantity<i16, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for i32 {
    type Output = Quantity<i32, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for i64 {
    type Output = Quantity<i64, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for i128 {
    type Output = Quantity<i128, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for isize {
    type Output = Quantity<isize, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for u8 {
    type Output = Quantity<u8, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for u16 {
    type Output = Quantity<u16, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for u32 {
    type Output = Quantity<u32, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for u64 {
    type Output = Quantity<u64, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for u128 {
    type Output = Quantity<u128, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for usize {
    type Output = Quantity<usize, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for f32 {
    type Output = Quantity<f32, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
impl Mul<UnitDecacandelasMul> for f64 {
    type Output = Quantity<f64, UnitDecacandelas>;
    fn mul(self, _: UnitDecacandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecacandelas)
    }
}
pub struct UnitDecicandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicandelas {
    #[inline]
    fn clone(&self) -> UnitDecicandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicandelas {
    #[inline]
    fn eq(&self, other: &UnitDecicandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecicandelas {
    fn default() -> Self {
        UnitDecicandelas
    }
}
impl Add<UnitDecicandelas> for UnitDecicandelas {
    type Output = UnitDecicandelas;
    #[inline]
    fn add(self, _: UnitDecicandelas) -> Self::Output {
        UnitDecicandelas
    }
}
impl AddAssign<UnitDecicandelas> for UnitDecicandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitDecicandelas) {}
}
impl Sub<UnitDecicandelas> for UnitDecicandelas {
    type Output = UnitDecicandelas;
    #[inline]
    fn sub(self, _: UnitDecicandelas) -> Self::Output {
        UnitDecicandelas
    }
}
impl SubAssign<UnitDecicandelas> for UnitDecicandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecicandelas) {}
}
pub struct UnitDecicandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicandelasMul {
    #[inline]
    fn clone(&self) -> UnitDecicandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicandelasMul {
    #[inline]
    fn eq(&self, other: &UnitDecicandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecicandelasMul> for i8 {
    type Output = Quantity<i8, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for i16 {
    type Output = Quantity<i16, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for i32 {
    type Output = Quantity<i32, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for i64 {
    type Output = Quantity<i64, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for i128 {
    type Output = Quantity<i128, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for isize {
    type Output = Quantity<isize, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for u8 {
    type Output = Quantity<u8, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for u16 {
    type Output = Quantity<u16, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for u32 {
    type Output = Quantity<u32, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for u64 {
    type Output = Quantity<u64, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for u128 {
    type Output = Quantity<u128, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for usize {
    type Output = Quantity<usize, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for f32 {
    type Output = Quantity<f32, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
impl Mul<UnitDecicandelasMul> for f64 {
    type Output = Quantity<f64, UnitDecicandelas>;
    fn mul(self, _: UnitDecicandelasMul) -> Self::Output {
        Quantity::new(self, UnitDecicandelas)
    }
}
pub struct UnitCenticandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticandelas {
    #[inline]
    fn clone(&self) -> UnitCenticandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticandelas {
    #[inline]
    fn eq(&self, other: &UnitCenticandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCenticandelas {
    fn default() -> Self {
        UnitCenticandelas
    }
}
impl Add<UnitCenticandelas> for UnitCenticandelas {
    type Output = UnitCenticandelas;
    #[inline]
    fn add(self, _: UnitCenticandelas) -> Self::Output {
        UnitCenticandelas
    }
}
impl AddAssign<UnitCenticandelas> for UnitCenticandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitCenticandelas) {}
}
impl Sub<UnitCenticandelas> for UnitCenticandelas {
    type Output = UnitCenticandelas;
    #[inline]
    fn sub(self, _: UnitCenticandelas) -> Self::Output {
        UnitCenticandelas
    }
}
impl SubAssign<UnitCenticandelas> for UnitCenticandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitCenticandelas) {}
}
pub struct UnitCenticandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticandelasMul {
    #[inline]
    fn clone(&self) -> UnitCenticandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticandelasMul {
    #[inline]
    fn eq(&self, other: &UnitCenticandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCenticandelasMul> for i8 {
    type Output = Quantity<i8, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for i16 {
    type Output = Quantity<i16, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for i32 {
    type Output = Quantity<i32, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for i64 {
    type Output = Quantity<i64, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for i128 {
    type Output = Quantity<i128, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for isize {
    type Output = Quantity<isize, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for u8 {
    type Output = Quantity<u8, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for u16 {
    type Output = Quantity<u16, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for u32 {
    type Output = Quantity<u32, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for u64 {
    type Output = Quantity<u64, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for u128 {
    type Output = Quantity<u128, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for usize {
    type Output = Quantity<usize, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for f32 {
    type Output = Quantity<f32, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
impl Mul<UnitCenticandelasMul> for f64 {
    type Output = Quantity<f64, UnitCenticandelas>;
    fn mul(self, _: UnitCenticandelasMul) -> Self::Output {
        Quantity::new(self, UnitCenticandelas)
    }
}
pub struct UnitMillicandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicandelas {
    #[inline]
    fn clone(&self) -> UnitMillicandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicandelas {
    #[inline]
    fn eq(&self, other: &UnitMillicandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillicandelas {
    fn default() -> Self {
        UnitMillicandelas
    }
}
impl Add<UnitMillicandelas> for UnitMillicandelas {
    type Output = UnitMillicandelas;
    #[inline]
    fn add(self, _: UnitMillicandelas) -> Self::Output {
        UnitMillicandelas
    }
}
impl AddAssign<UnitMillicandelas> for UnitMillicandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitMillicandelas) {}
}
impl Sub<UnitMillicandelas> for UnitMillicandelas {
    type Output = UnitMillicandelas;
    #[inline]
    fn sub(self, _: UnitMillicandelas) -> Self::Output {
        UnitMillicandelas
    }
}
impl SubAssign<UnitMillicandelas> for UnitMillicandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillicandelas) {}
}
pub struct UnitMillicandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicandelasMul {
    #[inline]
    fn clone(&self) -> UnitMillicandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicandelasMul {
    #[inline]
    fn eq(&self, other: &UnitMillicandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillicandelasMul> for i8 {
    type Output = Quantity<i8, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for i16 {
    type Output = Quantity<i16, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for i32 {
    type Output = Quantity<i32, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for i64 {
    type Output = Quantity<i64, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for i128 {
    type Output = Quantity<i128, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for isize {
    type Output = Quantity<isize, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for u8 {
    type Output = Quantity<u8, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for u16 {
    type Output = Quantity<u16, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for u32 {
    type Output = Quantity<u32, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for u64 {
    type Output = Quantity<u64, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for u128 {
    type Output = Quantity<u128, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for usize {
    type Output = Quantity<usize, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for f32 {
    type Output = Quantity<f32, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
impl Mul<UnitMillicandelasMul> for f64 {
    type Output = Quantity<f64, UnitMillicandelas>;
    fn mul(self, _: UnitMillicandelasMul) -> Self::Output {
        Quantity::new(self, UnitMillicandelas)
    }
}
pub struct UnitMicrocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocandelas {
    #[inline]
    fn clone(&self) -> UnitMicrocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocandelas {
    #[inline]
    fn eq(&self, other: &UnitMicrocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrocandelas {
    fn default() -> Self {
        UnitMicrocandelas
    }
}
impl Add<UnitMicrocandelas> for UnitMicrocandelas {
    type Output = UnitMicrocandelas;
    #[inline]
    fn add(self, _: UnitMicrocandelas) -> Self::Output {
        UnitMicrocandelas
    }
}
impl AddAssign<UnitMicrocandelas> for UnitMicrocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrocandelas) {}
}
impl Sub<UnitMicrocandelas> for UnitMicrocandelas {
    type Output = UnitMicrocandelas;
    #[inline]
    fn sub(self, _: UnitMicrocandelas) -> Self::Output {
        UnitMicrocandelas
    }
}
impl SubAssign<UnitMicrocandelas> for UnitMicrocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrocandelas) {}
}
pub struct UnitMicrocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocandelasMul {
    #[inline]
    fn clone(&self) -> UnitMicrocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitMicrocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrocandelasMul> for i8 {
    type Output = Quantity<i8, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for i16 {
    type Output = Quantity<i16, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for i32 {
    type Output = Quantity<i32, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for i64 {
    type Output = Quantity<i64, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for i128 {
    type Output = Quantity<i128, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for isize {
    type Output = Quantity<isize, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for u8 {
    type Output = Quantity<u8, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for u16 {
    type Output = Quantity<u16, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for u32 {
    type Output = Quantity<u32, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for u64 {
    type Output = Quantity<u64, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for u128 {
    type Output = Quantity<u128, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for usize {
    type Output = Quantity<usize, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for f32 {
    type Output = Quantity<f32, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
impl Mul<UnitMicrocandelasMul> for f64 {
    type Output = Quantity<f64, UnitMicrocandelas>;
    fn mul(self, _: UnitMicrocandelasMul) -> Self::Output {
        Quantity::new(self, UnitMicrocandelas)
    }
}
pub struct UnitNanocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocandelas {
    #[inline]
    fn clone(&self) -> UnitNanocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocandelas {
    #[inline]
    fn eq(&self, other: &UnitNanocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanocandelas {
    fn default() -> Self {
        UnitNanocandelas
    }
}
impl Add<UnitNanocandelas> for UnitNanocandelas {
    type Output = UnitNanocandelas;
    #[inline]
    fn add(self, _: UnitNanocandelas) -> Self::Output {
        UnitNanocandelas
    }
}
impl AddAssign<UnitNanocandelas> for UnitNanocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitNanocandelas) {}
}
impl Sub<UnitNanocandelas> for UnitNanocandelas {
    type Output = UnitNanocandelas;
    #[inline]
    fn sub(self, _: UnitNanocandelas) -> Self::Output {
        UnitNanocandelas
    }
}
impl SubAssign<UnitNanocandelas> for UnitNanocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanocandelas) {}
}
pub struct UnitNanocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocandelasMul {
    #[inline]
    fn clone(&self) -> UnitNanocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitNanocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanocandelasMul> for i8 {
    type Output = Quantity<i8, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for i16 {
    type Output = Quantity<i16, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for i32 {
    type Output = Quantity<i32, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for i64 {
    type Output = Quantity<i64, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for i128 {
    type Output = Quantity<i128, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for isize {
    type Output = Quantity<isize, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for u8 {
    type Output = Quantity<u8, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for u16 {
    type Output = Quantity<u16, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for u32 {
    type Output = Quantity<u32, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for u64 {
    type Output = Quantity<u64, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for u128 {
    type Output = Quantity<u128, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for usize {
    type Output = Quantity<usize, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for f32 {
    type Output = Quantity<f32, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
impl Mul<UnitNanocandelasMul> for f64 {
    type Output = Quantity<f64, UnitNanocandelas>;
    fn mul(self, _: UnitNanocandelasMul) -> Self::Output {
        Quantity::new(self, UnitNanocandelas)
    }
}
pub struct UnitPicocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocandelas {
    #[inline]
    fn clone(&self) -> UnitPicocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocandelas {
    #[inline]
    fn eq(&self, other: &UnitPicocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicocandelas {
    fn default() -> Self {
        UnitPicocandelas
    }
}
impl Add<UnitPicocandelas> for UnitPicocandelas {
    type Output = UnitPicocandelas;
    #[inline]
    fn add(self, _: UnitPicocandelas) -> Self::Output {
        UnitPicocandelas
    }
}
impl AddAssign<UnitPicocandelas> for UnitPicocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitPicocandelas) {}
}
impl Sub<UnitPicocandelas> for UnitPicocandelas {
    type Output = UnitPicocandelas;
    #[inline]
    fn sub(self, _: UnitPicocandelas) -> Self::Output {
        UnitPicocandelas
    }
}
impl SubAssign<UnitPicocandelas> for UnitPicocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicocandelas) {}
}
pub struct UnitPicocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocandelasMul {
    #[inline]
    fn clone(&self) -> UnitPicocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitPicocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicocandelasMul> for i8 {
    type Output = Quantity<i8, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for i16 {
    type Output = Quantity<i16, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for i32 {
    type Output = Quantity<i32, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for i64 {
    type Output = Quantity<i64, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for i128 {
    type Output = Quantity<i128, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for isize {
    type Output = Quantity<isize, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for u8 {
    type Output = Quantity<u8, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for u16 {
    type Output = Quantity<u16, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for u32 {
    type Output = Quantity<u32, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for u64 {
    type Output = Quantity<u64, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for u128 {
    type Output = Quantity<u128, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for usize {
    type Output = Quantity<usize, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for f32 {
    type Output = Quantity<f32, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
impl Mul<UnitPicocandelasMul> for f64 {
    type Output = Quantity<f64, UnitPicocandelas>;
    fn mul(self, _: UnitPicocandelasMul) -> Self::Output {
        Quantity::new(self, UnitPicocandelas)
    }
}
pub struct UnitFemtocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocandelas {
    #[inline]
    fn clone(&self) -> UnitFemtocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocandelas {
    #[inline]
    fn eq(&self, other: &UnitFemtocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtocandelas {
    fn default() -> Self {
        UnitFemtocandelas
    }
}
impl Add<UnitFemtocandelas> for UnitFemtocandelas {
    type Output = UnitFemtocandelas;
    #[inline]
    fn add(self, _: UnitFemtocandelas) -> Self::Output {
        UnitFemtocandelas
    }
}
impl AddAssign<UnitFemtocandelas> for UnitFemtocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtocandelas) {}
}
impl Sub<UnitFemtocandelas> for UnitFemtocandelas {
    type Output = UnitFemtocandelas;
    #[inline]
    fn sub(self, _: UnitFemtocandelas) -> Self::Output {
        UnitFemtocandelas
    }
}
impl SubAssign<UnitFemtocandelas> for UnitFemtocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtocandelas) {}
}
pub struct UnitFemtocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocandelasMul {
    #[inline]
    fn clone(&self) -> UnitFemtocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitFemtocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtocandelasMul> for i8 {
    type Output = Quantity<i8, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for i16 {
    type Output = Quantity<i16, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for i32 {
    type Output = Quantity<i32, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for i64 {
    type Output = Quantity<i64, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for i128 {
    type Output = Quantity<i128, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for isize {
    type Output = Quantity<isize, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for u8 {
    type Output = Quantity<u8, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for u16 {
    type Output = Quantity<u16, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for u32 {
    type Output = Quantity<u32, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for u64 {
    type Output = Quantity<u64, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for u128 {
    type Output = Quantity<u128, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for usize {
    type Output = Quantity<usize, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for f32 {
    type Output = Quantity<f32, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
impl Mul<UnitFemtocandelasMul> for f64 {
    type Output = Quantity<f64, UnitFemtocandelas>;
    fn mul(self, _: UnitFemtocandelasMul) -> Self::Output {
        Quantity::new(self, UnitFemtocandelas)
    }
}
pub struct UnitAttocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocandelas {
    #[inline]
    fn clone(&self) -> UnitAttocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocandelas {
    #[inline]
    fn eq(&self, other: &UnitAttocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttocandelas {
    fn default() -> Self {
        UnitAttocandelas
    }
}
impl Add<UnitAttocandelas> for UnitAttocandelas {
    type Output = UnitAttocandelas;
    #[inline]
    fn add(self, _: UnitAttocandelas) -> Self::Output {
        UnitAttocandelas
    }
}
impl AddAssign<UnitAttocandelas> for UnitAttocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitAttocandelas) {}
}
impl Sub<UnitAttocandelas> for UnitAttocandelas {
    type Output = UnitAttocandelas;
    #[inline]
    fn sub(self, _: UnitAttocandelas) -> Self::Output {
        UnitAttocandelas
    }
}
impl SubAssign<UnitAttocandelas> for UnitAttocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttocandelas) {}
}
pub struct UnitAttocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocandelasMul {
    #[inline]
    fn clone(&self) -> UnitAttocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitAttocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttocandelasMul> for i8 {
    type Output = Quantity<i8, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for i16 {
    type Output = Quantity<i16, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for i32 {
    type Output = Quantity<i32, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for i64 {
    type Output = Quantity<i64, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for i128 {
    type Output = Quantity<i128, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for isize {
    type Output = Quantity<isize, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for u8 {
    type Output = Quantity<u8, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for u16 {
    type Output = Quantity<u16, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for u32 {
    type Output = Quantity<u32, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for u64 {
    type Output = Quantity<u64, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for u128 {
    type Output = Quantity<u128, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for usize {
    type Output = Quantity<usize, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for f32 {
    type Output = Quantity<f32, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
impl Mul<UnitAttocandelasMul> for f64 {
    type Output = Quantity<f64, UnitAttocandelas>;
    fn mul(self, _: UnitAttocandelasMul) -> Self::Output {
        Quantity::new(self, UnitAttocandelas)
    }
}
pub struct UnitZeptocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocandelas {
    #[inline]
    fn clone(&self) -> UnitZeptocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocandelas {
    #[inline]
    fn eq(&self, other: &UnitZeptocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptocandelas {
    fn default() -> Self {
        UnitZeptocandelas
    }
}
impl Add<UnitZeptocandelas> for UnitZeptocandelas {
    type Output = UnitZeptocandelas;
    #[inline]
    fn add(self, _: UnitZeptocandelas) -> Self::Output {
        UnitZeptocandelas
    }
}
impl AddAssign<UnitZeptocandelas> for UnitZeptocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptocandelas) {}
}
impl Sub<UnitZeptocandelas> for UnitZeptocandelas {
    type Output = UnitZeptocandelas;
    #[inline]
    fn sub(self, _: UnitZeptocandelas) -> Self::Output {
        UnitZeptocandelas
    }
}
impl SubAssign<UnitZeptocandelas> for UnitZeptocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptocandelas) {}
}
pub struct UnitZeptocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocandelasMul {
    #[inline]
    fn clone(&self) -> UnitZeptocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitZeptocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptocandelasMul> for i8 {
    type Output = Quantity<i8, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for i16 {
    type Output = Quantity<i16, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for i32 {
    type Output = Quantity<i32, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for i64 {
    type Output = Quantity<i64, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for i128 {
    type Output = Quantity<i128, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for isize {
    type Output = Quantity<isize, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for u8 {
    type Output = Quantity<u8, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for u16 {
    type Output = Quantity<u16, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for u32 {
    type Output = Quantity<u32, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for u64 {
    type Output = Quantity<u64, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for u128 {
    type Output = Quantity<u128, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for usize {
    type Output = Quantity<usize, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for f32 {
    type Output = Quantity<f32, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
impl Mul<UnitZeptocandelasMul> for f64 {
    type Output = Quantity<f64, UnitZeptocandelas>;
    fn mul(self, _: UnitZeptocandelasMul) -> Self::Output {
        Quantity::new(self, UnitZeptocandelas)
    }
}
pub struct UnitYoctocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocandelas {
    #[inline]
    fn clone(&self) -> UnitYoctocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocandelas {
    #[inline]
    fn eq(&self, other: &UnitYoctocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctocandelas {
    fn default() -> Self {
        UnitYoctocandelas
    }
}
impl Add<UnitYoctocandelas> for UnitYoctocandelas {
    type Output = UnitYoctocandelas;
    #[inline]
    fn add(self, _: UnitYoctocandelas) -> Self::Output {
        UnitYoctocandelas
    }
}
impl AddAssign<UnitYoctocandelas> for UnitYoctocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctocandelas) {}
}
impl Sub<UnitYoctocandelas> for UnitYoctocandelas {
    type Output = UnitYoctocandelas;
    #[inline]
    fn sub(self, _: UnitYoctocandelas) -> Self::Output {
        UnitYoctocandelas
    }
}
impl SubAssign<UnitYoctocandelas> for UnitYoctocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctocandelas) {}
}
pub struct UnitYoctocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocandelasMul {
    #[inline]
    fn clone(&self) -> UnitYoctocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitYoctocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctocandelasMul> for i8 {
    type Output = Quantity<i8, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for i16 {
    type Output = Quantity<i16, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for i32 {
    type Output = Quantity<i32, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for i64 {
    type Output = Quantity<i64, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for i128 {
    type Output = Quantity<i128, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for isize {
    type Output = Quantity<isize, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for u8 {
    type Output = Quantity<u8, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for u16 {
    type Output = Quantity<u16, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for u32 {
    type Output = Quantity<u32, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for u64 {
    type Output = Quantity<u64, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for u128 {
    type Output = Quantity<u128, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for usize {
    type Output = Quantity<usize, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for f32 {
    type Output = Quantity<f32, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
impl Mul<UnitYoctocandelasMul> for f64 {
    type Output = Quantity<f64, UnitYoctocandelas>;
    fn mul(self, _: UnitYoctocandelasMul) -> Self::Output {
        Quantity::new(self, UnitYoctocandelas)
    }
}
pub struct UnitRontocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocandelas {
    #[inline]
    fn clone(&self) -> UnitRontocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocandelas {
    #[inline]
    fn eq(&self, other: &UnitRontocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontocandelas {
    fn default() -> Self {
        UnitRontocandelas
    }
}
impl Add<UnitRontocandelas> for UnitRontocandelas {
    type Output = UnitRontocandelas;
    #[inline]
    fn add(self, _: UnitRontocandelas) -> Self::Output {
        UnitRontocandelas
    }
}
impl AddAssign<UnitRontocandelas> for UnitRontocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitRontocandelas) {}
}
impl Sub<UnitRontocandelas> for UnitRontocandelas {
    type Output = UnitRontocandelas;
    #[inline]
    fn sub(self, _: UnitRontocandelas) -> Self::Output {
        UnitRontocandelas
    }
}
impl SubAssign<UnitRontocandelas> for UnitRontocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontocandelas) {}
}
pub struct UnitRontocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocandelasMul {
    #[inline]
    fn clone(&self) -> UnitRontocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitRontocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontocandelasMul> for i8 {
    type Output = Quantity<i8, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for i16 {
    type Output = Quantity<i16, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for i32 {
    type Output = Quantity<i32, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for i64 {
    type Output = Quantity<i64, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for i128 {
    type Output = Quantity<i128, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for isize {
    type Output = Quantity<isize, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for u8 {
    type Output = Quantity<u8, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for u16 {
    type Output = Quantity<u16, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for u32 {
    type Output = Quantity<u32, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for u64 {
    type Output = Quantity<u64, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for u128 {
    type Output = Quantity<u128, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for usize {
    type Output = Quantity<usize, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for f32 {
    type Output = Quantity<f32, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
impl Mul<UnitRontocandelasMul> for f64 {
    type Output = Quantity<f64, UnitRontocandelas>;
    fn mul(self, _: UnitRontocandelasMul) -> Self::Output {
        Quantity::new(self, UnitRontocandelas)
    }
}
pub struct UnitQuectocandelas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocandelas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocandelas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocandelas {
    #[inline]
    fn clone(&self) -> UnitQuectocandelas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocandelas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocandelas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocandelas {
    #[inline]
    fn eq(&self, other: &UnitQuectocandelas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocandelas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectocandelas {
    fn default() -> Self {
        UnitQuectocandelas
    }
}
impl Add<UnitQuectocandelas> for UnitQuectocandelas {
    type Output = UnitQuectocandelas;
    #[inline]
    fn add(self, _: UnitQuectocandelas) -> Self::Output {
        UnitQuectocandelas
    }
}
impl AddAssign<UnitQuectocandelas> for UnitQuectocandelas {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectocandelas) {}
}
impl Sub<UnitQuectocandelas> for UnitQuectocandelas {
    type Output = UnitQuectocandelas;
    #[inline]
    fn sub(self, _: UnitQuectocandelas) -> Self::Output {
        UnitQuectocandelas
    }
}
impl SubAssign<UnitQuectocandelas> for UnitQuectocandelas {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectocandelas) {}
}
pub struct UnitQuectocandelasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocandelasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocandelasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocandelasMul {
    #[inline]
    fn clone(&self) -> UnitQuectocandelasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocandelasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocandelasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocandelasMul {
    #[inline]
    fn eq(&self, other: &UnitQuectocandelasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocandelasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectocandelasMul> for i8 {
    type Output = Quantity<i8, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for i16 {
    type Output = Quantity<i16, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for i32 {
    type Output = Quantity<i32, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for i64 {
    type Output = Quantity<i64, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for i128 {
    type Output = Quantity<i128, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for isize {
    type Output = Quantity<isize, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for u8 {
    type Output = Quantity<u8, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for u16 {
    type Output = Quantity<u16, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for u32 {
    type Output = Quantity<u32, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for u64 {
    type Output = Quantity<u64, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for u128 {
    type Output = Quantity<u128, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for usize {
    type Output = Quantity<usize, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for f32 {
    type Output = Quantity<f32, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
impl Mul<UnitQuectocandelasMul> for f64 {
    type Output = Quantity<f64, UnitQuectocandelas>;
    fn mul(self, _: UnitQuectocandelasMul) -> Self::Output {
        Quantity::new(self, UnitQuectocandelas)
    }
}
pub type Candelas<T> = Quantity<T, UnitCandelas>;
#[allow(non_upper_case_globals)]
pub static Candelas: UnitCandelasMul = UnitCandelasMul;
pub type Quettacandelas<T> = Quantity<T, UnitQuettacandelas>;
#[allow(non_upper_case_globals)]
pub static Quettacandelas: UnitQuettacandelasMul = UnitQuettacandelasMul;
pub type Ronnacandelas<T> = Quantity<T, UnitRonnacandelas>;
#[allow(non_upper_case_globals)]
pub static Ronnacandelas: UnitRonnacandelasMul = UnitRonnacandelasMul;
pub type Yottacandelas<T> = Quantity<T, UnitYottacandelas>;
#[allow(non_upper_case_globals)]
pub static Yottacandelas: UnitYottacandelasMul = UnitYottacandelasMul;
pub type Zettacandelas<T> = Quantity<T, UnitZettacandelas>;
#[allow(non_upper_case_globals)]
pub static Zettacandelas: UnitZettacandelasMul = UnitZettacandelasMul;
pub type Exacandelas<T> = Quantity<T, UnitExacandelas>;
#[allow(non_upper_case_globals)]
pub static Exacandelas: UnitExacandelasMul = UnitExacandelasMul;
pub type Petacandelas<T> = Quantity<T, UnitPetacandelas>;
#[allow(non_upper_case_globals)]
pub static Petacandelas: UnitPetacandelasMul = UnitPetacandelasMul;
pub type Teracandelas<T> = Quantity<T, UnitTeracandelas>;
#[allow(non_upper_case_globals)]
pub static Teracandelas: UnitTeracandelasMul = UnitTeracandelasMul;
pub type Gigacandelas<T> = Quantity<T, UnitGigacandelas>;
#[allow(non_upper_case_globals)]
pub static Gigacandelas: UnitGigacandelasMul = UnitGigacandelasMul;
pub type Megacandelas<T> = Quantity<T, UnitMegacandelas>;
#[allow(non_upper_case_globals)]
pub static Megacandelas: UnitMegacandelasMul = UnitMegacandelasMul;
pub type Kilocandelas<T> = Quantity<T, UnitKilocandelas>;
#[allow(non_upper_case_globals)]
pub static Kilocandelas: UnitKilocandelasMul = UnitKilocandelasMul;
pub type Hectocandelas<T> = Quantity<T, UnitHectocandelas>;
#[allow(non_upper_case_globals)]
pub static Hectocandelas: UnitHectocandelasMul = UnitHectocandelasMul;
pub type Decacandelas<T> = Quantity<T, UnitDecacandelas>;
#[allow(non_upper_case_globals)]
pub static Decacandelas: UnitDecacandelasMul = UnitDecacandelasMul;
pub type Decicandelas<T> = Quantity<T, UnitDecicandelas>;
#[allow(non_upper_case_globals)]
pub static Decicandelas: UnitDecicandelasMul = UnitDecicandelasMul;
pub type Centicandelas<T> = Quantity<T, UnitCenticandelas>;
#[allow(non_upper_case_globals)]
pub static Centicandelas: UnitCenticandelasMul = UnitCenticandelasMul;
pub type Millicandelas<T> = Quantity<T, UnitMillicandelas>;
#[allow(non_upper_case_globals)]
pub static Millicandelas: UnitMillicandelasMul = UnitMillicandelasMul;
pub type Microcandelas<T> = Quantity<T, UnitMicrocandelas>;
#[allow(non_upper_case_globals)]
pub static Microcandelas: UnitMicrocandelasMul = UnitMicrocandelasMul;
pub type Nanocandelas<T> = Quantity<T, UnitNanocandelas>;
#[allow(non_upper_case_globals)]
pub static Nanocandelas: UnitNanocandelasMul = UnitNanocandelasMul;
pub type Picocandelas<T> = Quantity<T, UnitPicocandelas>;
#[allow(non_upper_case_globals)]
pub static Picocandelas: UnitPicocandelasMul = UnitPicocandelasMul;
pub type Femtocandelas<T> = Quantity<T, UnitFemtocandelas>;
#[allow(non_upper_case_globals)]
pub static Femtocandelas: UnitFemtocandelasMul = UnitFemtocandelasMul;
pub type Attocandelas<T> = Quantity<T, UnitAttocandelas>;
#[allow(non_upper_case_globals)]
pub static Attocandelas: UnitAttocandelasMul = UnitAttocandelasMul;
pub type Zeptocandelas<T> = Quantity<T, UnitZeptocandelas>;
#[allow(non_upper_case_globals)]
pub static Zeptocandelas: UnitZeptocandelasMul = UnitZeptocandelasMul;
pub type Yoctocandelas<T> = Quantity<T, UnitYoctocandelas>;
#[allow(non_upper_case_globals)]
pub static Yoctocandelas: UnitYoctocandelasMul = UnitYoctocandelasMul;
pub type Rontocandelas<T> = Quantity<T, UnitRontocandelas>;
#[allow(non_upper_case_globals)]
pub static Rontocandelas: UnitRontocandelasMul = UnitRontocandelasMul;
pub type Quectocandelas<T> = Quantity<T, UnitQuectocandelas>;
#[allow(non_upper_case_globals)]
pub static Quectocandelas: UnitQuectocandelasMul = UnitQuectocandelasMul;
pub struct UnitRadians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRadians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRadians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRadians {
    #[inline]
    fn clone(&self) -> UnitRadians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRadians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRadians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRadians {
    #[inline]
    fn eq(&self, other: &UnitRadians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRadians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRadians {
    fn default() -> Self {
        UnitRadians
    }
}
impl Add<UnitRadians> for UnitRadians {
    type Output = UnitRadians;
    #[inline]
    fn add(self, _: UnitRadians) -> Self::Output {
        UnitRadians
    }
}
impl AddAssign<UnitRadians> for UnitRadians {
    #[inline]
    fn add_assign(&mut self, _: UnitRadians) {}
}
impl Sub<UnitRadians> for UnitRadians {
    type Output = UnitRadians;
    #[inline]
    fn sub(self, _: UnitRadians) -> Self::Output {
        UnitRadians
    }
}
impl SubAssign<UnitRadians> for UnitRadians {
    #[inline]
    fn sub_assign(&mut self, _: UnitRadians) {}
}
pub struct UnitRadiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRadiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRadiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRadiansMul {
    #[inline]
    fn clone(&self) -> UnitRadiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRadiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRadiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRadiansMul {
    #[inline]
    fn eq(&self, other: &UnitRadiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRadiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRadiansMul> for i8 {
    type Output = Quantity<i8, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for i16 {
    type Output = Quantity<i16, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for i32 {
    type Output = Quantity<i32, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for i64 {
    type Output = Quantity<i64, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for i128 {
    type Output = Quantity<i128, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for isize {
    type Output = Quantity<isize, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for u8 {
    type Output = Quantity<u8, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for u16 {
    type Output = Quantity<u16, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for u32 {
    type Output = Quantity<u32, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for u64 {
    type Output = Quantity<u64, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for u128 {
    type Output = Quantity<u128, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for usize {
    type Output = Quantity<usize, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for f32 {
    type Output = Quantity<f32, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
impl Mul<UnitRadiansMul> for f64 {
    type Output = Quantity<f64, UnitRadians>;
    fn mul(self, _: UnitRadiansMul) -> Self::Output {
        Quantity::new(self, UnitRadians)
    }
}
pub struct UnitQuettaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaradians {
    #[inline]
    fn clone(&self) -> UnitQuettaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaradians {
    #[inline]
    fn eq(&self, other: &UnitQuettaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaradians {
    fn default() -> Self {
        UnitQuettaradians
    }
}
impl Add<UnitQuettaradians> for UnitQuettaradians {
    type Output = UnitQuettaradians;
    #[inline]
    fn add(self, _: UnitQuettaradians) -> Self::Output {
        UnitQuettaradians
    }
}
impl AddAssign<UnitQuettaradians> for UnitQuettaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaradians) {}
}
impl Sub<UnitQuettaradians> for UnitQuettaradians {
    type Output = UnitQuettaradians;
    #[inline]
    fn sub(self, _: UnitQuettaradians) -> Self::Output {
        UnitQuettaradians
    }
}
impl SubAssign<UnitQuettaradians> for UnitQuettaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaradians) {}
}
pub struct UnitQuettaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaradiansMul {
    #[inline]
    fn clone(&self) -> UnitQuettaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaradiansMul> for i8 {
    type Output = Quantity<i8, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for i16 {
    type Output = Quantity<i16, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for i32 {
    type Output = Quantity<i32, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for i64 {
    type Output = Quantity<i64, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for i128 {
    type Output = Quantity<i128, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for isize {
    type Output = Quantity<isize, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for u8 {
    type Output = Quantity<u8, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for u16 {
    type Output = Quantity<u16, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for u32 {
    type Output = Quantity<u32, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for u64 {
    type Output = Quantity<u64, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for u128 {
    type Output = Quantity<u128, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for usize {
    type Output = Quantity<usize, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for f32 {
    type Output = Quantity<f32, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
impl Mul<UnitQuettaradiansMul> for f64 {
    type Output = Quantity<f64, UnitQuettaradians>;
    fn mul(self, _: UnitQuettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettaradians)
    }
}
pub struct UnitRonnaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaradians {
    #[inline]
    fn clone(&self) -> UnitRonnaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaradians {
    #[inline]
    fn eq(&self, other: &UnitRonnaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaradians {
    fn default() -> Self {
        UnitRonnaradians
    }
}
impl Add<UnitRonnaradians> for UnitRonnaradians {
    type Output = UnitRonnaradians;
    #[inline]
    fn add(self, _: UnitRonnaradians) -> Self::Output {
        UnitRonnaradians
    }
}
impl AddAssign<UnitRonnaradians> for UnitRonnaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaradians) {}
}
impl Sub<UnitRonnaradians> for UnitRonnaradians {
    type Output = UnitRonnaradians;
    #[inline]
    fn sub(self, _: UnitRonnaradians) -> Self::Output {
        UnitRonnaradians
    }
}
impl SubAssign<UnitRonnaradians> for UnitRonnaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaradians) {}
}
pub struct UnitRonnaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaradiansMul {
    #[inline]
    fn clone(&self) -> UnitRonnaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaradiansMul> for i8 {
    type Output = Quantity<i8, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for i16 {
    type Output = Quantity<i16, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for i32 {
    type Output = Quantity<i32, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for i64 {
    type Output = Quantity<i64, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for i128 {
    type Output = Quantity<i128, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for isize {
    type Output = Quantity<isize, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for u8 {
    type Output = Quantity<u8, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for u16 {
    type Output = Quantity<u16, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for u32 {
    type Output = Quantity<u32, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for u64 {
    type Output = Quantity<u64, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for u128 {
    type Output = Quantity<u128, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for usize {
    type Output = Quantity<usize, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for f32 {
    type Output = Quantity<f32, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
impl Mul<UnitRonnaradiansMul> for f64 {
    type Output = Quantity<f64, UnitRonnaradians>;
    fn mul(self, _: UnitRonnaradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnaradians)
    }
}
pub struct UnitYottaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaradians {
    #[inline]
    fn clone(&self) -> UnitYottaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaradians {
    #[inline]
    fn eq(&self, other: &UnitYottaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaradians {
    fn default() -> Self {
        UnitYottaradians
    }
}
impl Add<UnitYottaradians> for UnitYottaradians {
    type Output = UnitYottaradians;
    #[inline]
    fn add(self, _: UnitYottaradians) -> Self::Output {
        UnitYottaradians
    }
}
impl AddAssign<UnitYottaradians> for UnitYottaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaradians) {}
}
impl Sub<UnitYottaradians> for UnitYottaradians {
    type Output = UnitYottaradians;
    #[inline]
    fn sub(self, _: UnitYottaradians) -> Self::Output {
        UnitYottaradians
    }
}
impl SubAssign<UnitYottaradians> for UnitYottaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaradians) {}
}
pub struct UnitYottaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaradiansMul {
    #[inline]
    fn clone(&self) -> UnitYottaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitYottaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaradiansMul> for i8 {
    type Output = Quantity<i8, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for i16 {
    type Output = Quantity<i16, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for i32 {
    type Output = Quantity<i32, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for i64 {
    type Output = Quantity<i64, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for i128 {
    type Output = Quantity<i128, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for isize {
    type Output = Quantity<isize, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for u8 {
    type Output = Quantity<u8, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for u16 {
    type Output = Quantity<u16, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for u32 {
    type Output = Quantity<u32, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for u64 {
    type Output = Quantity<u64, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for u128 {
    type Output = Quantity<u128, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for usize {
    type Output = Quantity<usize, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for f32 {
    type Output = Quantity<f32, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
impl Mul<UnitYottaradiansMul> for f64 {
    type Output = Quantity<f64, UnitYottaradians>;
    fn mul(self, _: UnitYottaradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottaradians)
    }
}
pub struct UnitZettaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaradians {
    #[inline]
    fn clone(&self) -> UnitZettaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaradians {
    #[inline]
    fn eq(&self, other: &UnitZettaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaradians {
    fn default() -> Self {
        UnitZettaradians
    }
}
impl Add<UnitZettaradians> for UnitZettaradians {
    type Output = UnitZettaradians;
    #[inline]
    fn add(self, _: UnitZettaradians) -> Self::Output {
        UnitZettaradians
    }
}
impl AddAssign<UnitZettaradians> for UnitZettaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaradians) {}
}
impl Sub<UnitZettaradians> for UnitZettaradians {
    type Output = UnitZettaradians;
    #[inline]
    fn sub(self, _: UnitZettaradians) -> Self::Output {
        UnitZettaradians
    }
}
impl SubAssign<UnitZettaradians> for UnitZettaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaradians) {}
}
pub struct UnitZettaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaradiansMul {
    #[inline]
    fn clone(&self) -> UnitZettaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitZettaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaradiansMul> for i8 {
    type Output = Quantity<i8, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for i16 {
    type Output = Quantity<i16, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for i32 {
    type Output = Quantity<i32, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for i64 {
    type Output = Quantity<i64, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for i128 {
    type Output = Quantity<i128, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for isize {
    type Output = Quantity<isize, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for u8 {
    type Output = Quantity<u8, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for u16 {
    type Output = Quantity<u16, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for u32 {
    type Output = Quantity<u32, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for u64 {
    type Output = Quantity<u64, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for u128 {
    type Output = Quantity<u128, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for usize {
    type Output = Quantity<usize, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for f32 {
    type Output = Quantity<f32, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
impl Mul<UnitZettaradiansMul> for f64 {
    type Output = Quantity<f64, UnitZettaradians>;
    fn mul(self, _: UnitZettaradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettaradians)
    }
}
pub struct UnitExaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaradians {
    #[inline]
    fn clone(&self) -> UnitExaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaradians {
    #[inline]
    fn eq(&self, other: &UnitExaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaradians {
    fn default() -> Self {
        UnitExaradians
    }
}
impl Add<UnitExaradians> for UnitExaradians {
    type Output = UnitExaradians;
    #[inline]
    fn add(self, _: UnitExaradians) -> Self::Output {
        UnitExaradians
    }
}
impl AddAssign<UnitExaradians> for UnitExaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitExaradians) {}
}
impl Sub<UnitExaradians> for UnitExaradians {
    type Output = UnitExaradians;
    #[inline]
    fn sub(self, _: UnitExaradians) -> Self::Output {
        UnitExaradians
    }
}
impl SubAssign<UnitExaradians> for UnitExaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaradians) {}
}
pub struct UnitExaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaradiansMul {
    #[inline]
    fn clone(&self) -> UnitExaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitExaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaradiansMul> for i8 {
    type Output = Quantity<i8, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for i16 {
    type Output = Quantity<i16, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for i32 {
    type Output = Quantity<i32, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for i64 {
    type Output = Quantity<i64, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for i128 {
    type Output = Quantity<i128, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for isize {
    type Output = Quantity<isize, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for u8 {
    type Output = Quantity<u8, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for u16 {
    type Output = Quantity<u16, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for u32 {
    type Output = Quantity<u32, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for u64 {
    type Output = Quantity<u64, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for u128 {
    type Output = Quantity<u128, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for usize {
    type Output = Quantity<usize, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for f32 {
    type Output = Quantity<f32, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
impl Mul<UnitExaradiansMul> for f64 {
    type Output = Quantity<f64, UnitExaradians>;
    fn mul(self, _: UnitExaradiansMul) -> Self::Output {
        Quantity::new(self, UnitExaradians)
    }
}
pub struct UnitPetaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaradians {
    #[inline]
    fn clone(&self) -> UnitPetaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaradians {
    #[inline]
    fn eq(&self, other: &UnitPetaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaradians {
    fn default() -> Self {
        UnitPetaradians
    }
}
impl Add<UnitPetaradians> for UnitPetaradians {
    type Output = UnitPetaradians;
    #[inline]
    fn add(self, _: UnitPetaradians) -> Self::Output {
        UnitPetaradians
    }
}
impl AddAssign<UnitPetaradians> for UnitPetaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaradians) {}
}
impl Sub<UnitPetaradians> for UnitPetaradians {
    type Output = UnitPetaradians;
    #[inline]
    fn sub(self, _: UnitPetaradians) -> Self::Output {
        UnitPetaradians
    }
}
impl SubAssign<UnitPetaradians> for UnitPetaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaradians) {}
}
pub struct UnitPetaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaradiansMul {
    #[inline]
    fn clone(&self) -> UnitPetaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitPetaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaradiansMul> for i8 {
    type Output = Quantity<i8, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for i16 {
    type Output = Quantity<i16, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for i32 {
    type Output = Quantity<i32, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for i64 {
    type Output = Quantity<i64, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for i128 {
    type Output = Quantity<i128, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for isize {
    type Output = Quantity<isize, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for u8 {
    type Output = Quantity<u8, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for u16 {
    type Output = Quantity<u16, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for u32 {
    type Output = Quantity<u32, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for u64 {
    type Output = Quantity<u64, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for u128 {
    type Output = Quantity<u128, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for usize {
    type Output = Quantity<usize, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for f32 {
    type Output = Quantity<f32, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
impl Mul<UnitPetaradiansMul> for f64 {
    type Output = Quantity<f64, UnitPetaradians>;
    fn mul(self, _: UnitPetaradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetaradians)
    }
}
pub struct UnitTeraradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraradians {
    #[inline]
    fn clone(&self) -> UnitTeraradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraradians {
    #[inline]
    fn eq(&self, other: &UnitTeraradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraradians {
    fn default() -> Self {
        UnitTeraradians
    }
}
impl Add<UnitTeraradians> for UnitTeraradians {
    type Output = UnitTeraradians;
    #[inline]
    fn add(self, _: UnitTeraradians) -> Self::Output {
        UnitTeraradians
    }
}
impl AddAssign<UnitTeraradians> for UnitTeraradians {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraradians) {}
}
impl Sub<UnitTeraradians> for UnitTeraradians {
    type Output = UnitTeraradians;
    #[inline]
    fn sub(self, _: UnitTeraradians) -> Self::Output {
        UnitTeraradians
    }
}
impl SubAssign<UnitTeraradians> for UnitTeraradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraradians) {}
}
pub struct UnitTeraradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraradiansMul {
    #[inline]
    fn clone(&self) -> UnitTeraradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraradiansMul {
    #[inline]
    fn eq(&self, other: &UnitTeraradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraradiansMul> for i8 {
    type Output = Quantity<i8, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for i16 {
    type Output = Quantity<i16, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for i32 {
    type Output = Quantity<i32, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for i64 {
    type Output = Quantity<i64, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for i128 {
    type Output = Quantity<i128, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for isize {
    type Output = Quantity<isize, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for u8 {
    type Output = Quantity<u8, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for u16 {
    type Output = Quantity<u16, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for u32 {
    type Output = Quantity<u32, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for u64 {
    type Output = Quantity<u64, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for u128 {
    type Output = Quantity<u128, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for usize {
    type Output = Quantity<usize, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for f32 {
    type Output = Quantity<f32, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
impl Mul<UnitTeraradiansMul> for f64 {
    type Output = Quantity<f64, UnitTeraradians>;
    fn mul(self, _: UnitTeraradiansMul) -> Self::Output {
        Quantity::new(self, UnitTeraradians)
    }
}
pub struct UnitGigaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaradians {
    #[inline]
    fn clone(&self) -> UnitGigaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaradians {
    #[inline]
    fn eq(&self, other: &UnitGigaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaradians {
    fn default() -> Self {
        UnitGigaradians
    }
}
impl Add<UnitGigaradians> for UnitGigaradians {
    type Output = UnitGigaradians;
    #[inline]
    fn add(self, _: UnitGigaradians) -> Self::Output {
        UnitGigaradians
    }
}
impl AddAssign<UnitGigaradians> for UnitGigaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaradians) {}
}
impl Sub<UnitGigaradians> for UnitGigaradians {
    type Output = UnitGigaradians;
    #[inline]
    fn sub(self, _: UnitGigaradians) -> Self::Output {
        UnitGigaradians
    }
}
impl SubAssign<UnitGigaradians> for UnitGigaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaradians) {}
}
pub struct UnitGigaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaradiansMul {
    #[inline]
    fn clone(&self) -> UnitGigaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitGigaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaradiansMul> for i8 {
    type Output = Quantity<i8, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for i16 {
    type Output = Quantity<i16, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for i32 {
    type Output = Quantity<i32, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for i64 {
    type Output = Quantity<i64, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for i128 {
    type Output = Quantity<i128, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for isize {
    type Output = Quantity<isize, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for u8 {
    type Output = Quantity<u8, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for u16 {
    type Output = Quantity<u16, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for u32 {
    type Output = Quantity<u32, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for u64 {
    type Output = Quantity<u64, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for u128 {
    type Output = Quantity<u128, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for usize {
    type Output = Quantity<usize, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for f32 {
    type Output = Quantity<f32, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
impl Mul<UnitGigaradiansMul> for f64 {
    type Output = Quantity<f64, UnitGigaradians>;
    fn mul(self, _: UnitGigaradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigaradians)
    }
}
pub struct UnitMegaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaradians {
    #[inline]
    fn clone(&self) -> UnitMegaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaradians {
    #[inline]
    fn eq(&self, other: &UnitMegaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaradians {
    fn default() -> Self {
        UnitMegaradians
    }
}
impl Add<UnitMegaradians> for UnitMegaradians {
    type Output = UnitMegaradians;
    #[inline]
    fn add(self, _: UnitMegaradians) -> Self::Output {
        UnitMegaradians
    }
}
impl AddAssign<UnitMegaradians> for UnitMegaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaradians) {}
}
impl Sub<UnitMegaradians> for UnitMegaradians {
    type Output = UnitMegaradians;
    #[inline]
    fn sub(self, _: UnitMegaradians) -> Self::Output {
        UnitMegaradians
    }
}
impl SubAssign<UnitMegaradians> for UnitMegaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaradians) {}
}
pub struct UnitMegaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaradiansMul {
    #[inline]
    fn clone(&self) -> UnitMegaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMegaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaradiansMul> for i8 {
    type Output = Quantity<i8, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for i16 {
    type Output = Quantity<i16, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for i32 {
    type Output = Quantity<i32, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for i64 {
    type Output = Quantity<i64, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for i128 {
    type Output = Quantity<i128, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for isize {
    type Output = Quantity<isize, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for u8 {
    type Output = Quantity<u8, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for u16 {
    type Output = Quantity<u16, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for u32 {
    type Output = Quantity<u32, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for u64 {
    type Output = Quantity<u64, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for u128 {
    type Output = Quantity<u128, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for usize {
    type Output = Quantity<usize, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for f32 {
    type Output = Quantity<f32, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
impl Mul<UnitMegaradiansMul> for f64 {
    type Output = Quantity<f64, UnitMegaradians>;
    fn mul(self, _: UnitMegaradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegaradians)
    }
}
pub struct UnitKiloradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloradians {
    #[inline]
    fn clone(&self) -> UnitKiloradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloradians {
    #[inline]
    fn eq(&self, other: &UnitKiloradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloradians {
    fn default() -> Self {
        UnitKiloradians
    }
}
impl Add<UnitKiloradians> for UnitKiloradians {
    type Output = UnitKiloradians;
    #[inline]
    fn add(self, _: UnitKiloradians) -> Self::Output {
        UnitKiloradians
    }
}
impl AddAssign<UnitKiloradians> for UnitKiloradians {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloradians) {}
}
impl Sub<UnitKiloradians> for UnitKiloradians {
    type Output = UnitKiloradians;
    #[inline]
    fn sub(self, _: UnitKiloradians) -> Self::Output {
        UnitKiloradians
    }
}
impl SubAssign<UnitKiloradians> for UnitKiloradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloradians) {}
}
pub struct UnitKiloradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloradiansMul {
    #[inline]
    fn clone(&self) -> UnitKiloradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloradiansMul {
    #[inline]
    fn eq(&self, other: &UnitKiloradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloradiansMul> for i8 {
    type Output = Quantity<i8, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for i16 {
    type Output = Quantity<i16, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for i32 {
    type Output = Quantity<i32, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for i64 {
    type Output = Quantity<i64, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for i128 {
    type Output = Quantity<i128, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for isize {
    type Output = Quantity<isize, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for u8 {
    type Output = Quantity<u8, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for u16 {
    type Output = Quantity<u16, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for u32 {
    type Output = Quantity<u32, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for u64 {
    type Output = Quantity<u64, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for u128 {
    type Output = Quantity<u128, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for usize {
    type Output = Quantity<usize, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for f32 {
    type Output = Quantity<f32, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
impl Mul<UnitKiloradiansMul> for f64 {
    type Output = Quantity<f64, UnitKiloradians>;
    fn mul(self, _: UnitKiloradiansMul) -> Self::Output {
        Quantity::new(self, UnitKiloradians)
    }
}
pub struct UnitHectoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoradians {
    #[inline]
    fn clone(&self) -> UnitHectoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoradians {
    #[inline]
    fn eq(&self, other: &UnitHectoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoradians {
    fn default() -> Self {
        UnitHectoradians
    }
}
impl Add<UnitHectoradians> for UnitHectoradians {
    type Output = UnitHectoradians;
    #[inline]
    fn add(self, _: UnitHectoradians) -> Self::Output {
        UnitHectoradians
    }
}
impl AddAssign<UnitHectoradians> for UnitHectoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoradians) {}
}
impl Sub<UnitHectoradians> for UnitHectoradians {
    type Output = UnitHectoradians;
    #[inline]
    fn sub(self, _: UnitHectoradians) -> Self::Output {
        UnitHectoradians
    }
}
impl SubAssign<UnitHectoradians> for UnitHectoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoradians) {}
}
pub struct UnitHectoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoradiansMul {
    #[inline]
    fn clone(&self) -> UnitHectoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitHectoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoradiansMul> for i8 {
    type Output = Quantity<i8, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for i16 {
    type Output = Quantity<i16, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for i32 {
    type Output = Quantity<i32, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for i64 {
    type Output = Quantity<i64, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for i128 {
    type Output = Quantity<i128, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for isize {
    type Output = Quantity<isize, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for u8 {
    type Output = Quantity<u8, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for u16 {
    type Output = Quantity<u16, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for u32 {
    type Output = Quantity<u32, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for u64 {
    type Output = Quantity<u64, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for u128 {
    type Output = Quantity<u128, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for usize {
    type Output = Quantity<usize, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for f32 {
    type Output = Quantity<f32, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
impl Mul<UnitHectoradiansMul> for f64 {
    type Output = Quantity<f64, UnitHectoradians>;
    fn mul(self, _: UnitHectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectoradians)
    }
}
pub struct UnitDecaradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaradians {
    #[inline]
    fn clone(&self) -> UnitDecaradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaradians {
    #[inline]
    fn eq(&self, other: &UnitDecaradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaradians {
    fn default() -> Self {
        UnitDecaradians
    }
}
impl Add<UnitDecaradians> for UnitDecaradians {
    type Output = UnitDecaradians;
    #[inline]
    fn add(self, _: UnitDecaradians) -> Self::Output {
        UnitDecaradians
    }
}
impl AddAssign<UnitDecaradians> for UnitDecaradians {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaradians) {}
}
impl Sub<UnitDecaradians> for UnitDecaradians {
    type Output = UnitDecaradians;
    #[inline]
    fn sub(self, _: UnitDecaradians) -> Self::Output {
        UnitDecaradians
    }
}
impl SubAssign<UnitDecaradians> for UnitDecaradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaradians) {}
}
pub struct UnitDecaradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaradiansMul {
    #[inline]
    fn clone(&self) -> UnitDecaradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaradiansMul {
    #[inline]
    fn eq(&self, other: &UnitDecaradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaradiansMul> for i8 {
    type Output = Quantity<i8, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for i16 {
    type Output = Quantity<i16, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for i32 {
    type Output = Quantity<i32, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for i64 {
    type Output = Quantity<i64, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for i128 {
    type Output = Quantity<i128, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for isize {
    type Output = Quantity<isize, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for u8 {
    type Output = Quantity<u8, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for u16 {
    type Output = Quantity<u16, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for u32 {
    type Output = Quantity<u32, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for u64 {
    type Output = Quantity<u64, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for u128 {
    type Output = Quantity<u128, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for usize {
    type Output = Quantity<usize, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for f32 {
    type Output = Quantity<f32, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
impl Mul<UnitDecaradiansMul> for f64 {
    type Output = Quantity<f64, UnitDecaradians>;
    fn mul(self, _: UnitDecaradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecaradians)
    }
}
pub struct UnitDeciradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciradians {
    #[inline]
    fn clone(&self) -> UnitDeciradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciradians {
    #[inline]
    fn eq(&self, other: &UnitDeciradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciradians {
    fn default() -> Self {
        UnitDeciradians
    }
}
impl Add<UnitDeciradians> for UnitDeciradians {
    type Output = UnitDeciradians;
    #[inline]
    fn add(self, _: UnitDeciradians) -> Self::Output {
        UnitDeciradians
    }
}
impl AddAssign<UnitDeciradians> for UnitDeciradians {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciradians) {}
}
impl Sub<UnitDeciradians> for UnitDeciradians {
    type Output = UnitDeciradians;
    #[inline]
    fn sub(self, _: UnitDeciradians) -> Self::Output {
        UnitDeciradians
    }
}
impl SubAssign<UnitDeciradians> for UnitDeciradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciradians) {}
}
pub struct UnitDeciradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciradiansMul {
    #[inline]
    fn clone(&self) -> UnitDeciradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciradiansMul {
    #[inline]
    fn eq(&self, other: &UnitDeciradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciradiansMul> for i8 {
    type Output = Quantity<i8, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for i16 {
    type Output = Quantity<i16, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for i32 {
    type Output = Quantity<i32, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for i64 {
    type Output = Quantity<i64, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for i128 {
    type Output = Quantity<i128, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for isize {
    type Output = Quantity<isize, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for u8 {
    type Output = Quantity<u8, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for u16 {
    type Output = Quantity<u16, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for u32 {
    type Output = Quantity<u32, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for u64 {
    type Output = Quantity<u64, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for u128 {
    type Output = Quantity<u128, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for usize {
    type Output = Quantity<usize, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for f32 {
    type Output = Quantity<f32, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
impl Mul<UnitDeciradiansMul> for f64 {
    type Output = Quantity<f64, UnitDeciradians>;
    fn mul(self, _: UnitDeciradiansMul) -> Self::Output {
        Quantity::new(self, UnitDeciradians)
    }
}
pub struct UnitCentiradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiradians {
    #[inline]
    fn clone(&self) -> UnitCentiradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiradians {
    #[inline]
    fn eq(&self, other: &UnitCentiradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiradians {
    fn default() -> Self {
        UnitCentiradians
    }
}
impl Add<UnitCentiradians> for UnitCentiradians {
    type Output = UnitCentiradians;
    #[inline]
    fn add(self, _: UnitCentiradians) -> Self::Output {
        UnitCentiradians
    }
}
impl AddAssign<UnitCentiradians> for UnitCentiradians {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiradians) {}
}
impl Sub<UnitCentiradians> for UnitCentiradians {
    type Output = UnitCentiradians;
    #[inline]
    fn sub(self, _: UnitCentiradians) -> Self::Output {
        UnitCentiradians
    }
}
impl SubAssign<UnitCentiradians> for UnitCentiradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiradians) {}
}
pub struct UnitCentiradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiradiansMul {
    #[inline]
    fn clone(&self) -> UnitCentiradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiradiansMul {
    #[inline]
    fn eq(&self, other: &UnitCentiradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiradiansMul> for i8 {
    type Output = Quantity<i8, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for i16 {
    type Output = Quantity<i16, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for i32 {
    type Output = Quantity<i32, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for i64 {
    type Output = Quantity<i64, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for i128 {
    type Output = Quantity<i128, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for isize {
    type Output = Quantity<isize, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for u8 {
    type Output = Quantity<u8, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for u16 {
    type Output = Quantity<u16, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for u32 {
    type Output = Quantity<u32, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for u64 {
    type Output = Quantity<u64, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for u128 {
    type Output = Quantity<u128, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for usize {
    type Output = Quantity<usize, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for f32 {
    type Output = Quantity<f32, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
impl Mul<UnitCentiradiansMul> for f64 {
    type Output = Quantity<f64, UnitCentiradians>;
    fn mul(self, _: UnitCentiradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentiradians)
    }
}
pub struct UnitMilliradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliradians {
    #[inline]
    fn clone(&self) -> UnitMilliradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliradians {
    #[inline]
    fn eq(&self, other: &UnitMilliradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliradians {
    fn default() -> Self {
        UnitMilliradians
    }
}
impl Add<UnitMilliradians> for UnitMilliradians {
    type Output = UnitMilliradians;
    #[inline]
    fn add(self, _: UnitMilliradians) -> Self::Output {
        UnitMilliradians
    }
}
impl AddAssign<UnitMilliradians> for UnitMilliradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliradians) {}
}
impl Sub<UnitMilliradians> for UnitMilliradians {
    type Output = UnitMilliradians;
    #[inline]
    fn sub(self, _: UnitMilliradians) -> Self::Output {
        UnitMilliradians
    }
}
impl SubAssign<UnitMilliradians> for UnitMilliradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliradians) {}
}
pub struct UnitMilliradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliradiansMul {
    #[inline]
    fn clone(&self) -> UnitMilliradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMilliradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliradiansMul> for i8 {
    type Output = Quantity<i8, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for i16 {
    type Output = Quantity<i16, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for i32 {
    type Output = Quantity<i32, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for i64 {
    type Output = Quantity<i64, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for i128 {
    type Output = Quantity<i128, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for isize {
    type Output = Quantity<isize, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for u8 {
    type Output = Quantity<u8, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for u16 {
    type Output = Quantity<u16, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for u32 {
    type Output = Quantity<u32, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for u64 {
    type Output = Quantity<u64, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for u128 {
    type Output = Quantity<u128, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for usize {
    type Output = Quantity<usize, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for f32 {
    type Output = Quantity<f32, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
impl Mul<UnitMilliradiansMul> for f64 {
    type Output = Quantity<f64, UnitMilliradians>;
    fn mul(self, _: UnitMilliradiansMul) -> Self::Output {
        Quantity::new(self, UnitMilliradians)
    }
}
pub struct UnitMicroradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroradians {
    #[inline]
    fn clone(&self) -> UnitMicroradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroradians {
    #[inline]
    fn eq(&self, other: &UnitMicroradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroradians {
    fn default() -> Self {
        UnitMicroradians
    }
}
impl Add<UnitMicroradians> for UnitMicroradians {
    type Output = UnitMicroradians;
    #[inline]
    fn add(self, _: UnitMicroradians) -> Self::Output {
        UnitMicroradians
    }
}
impl AddAssign<UnitMicroradians> for UnitMicroradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroradians) {}
}
impl Sub<UnitMicroradians> for UnitMicroradians {
    type Output = UnitMicroradians;
    #[inline]
    fn sub(self, _: UnitMicroradians) -> Self::Output {
        UnitMicroradians
    }
}
impl SubAssign<UnitMicroradians> for UnitMicroradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroradians) {}
}
pub struct UnitMicroradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroradiansMul {
    #[inline]
    fn clone(&self) -> UnitMicroradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMicroradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroradiansMul> for i8 {
    type Output = Quantity<i8, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for i16 {
    type Output = Quantity<i16, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for i32 {
    type Output = Quantity<i32, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for i64 {
    type Output = Quantity<i64, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for i128 {
    type Output = Quantity<i128, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for isize {
    type Output = Quantity<isize, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for u8 {
    type Output = Quantity<u8, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for u16 {
    type Output = Quantity<u16, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for u32 {
    type Output = Quantity<u32, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for u64 {
    type Output = Quantity<u64, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for u128 {
    type Output = Quantity<u128, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for usize {
    type Output = Quantity<usize, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for f32 {
    type Output = Quantity<f32, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
impl Mul<UnitMicroradiansMul> for f64 {
    type Output = Quantity<f64, UnitMicroradians>;
    fn mul(self, _: UnitMicroradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicroradians)
    }
}
pub struct UnitNanoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoradians {
    #[inline]
    fn clone(&self) -> UnitNanoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoradians {
    #[inline]
    fn eq(&self, other: &UnitNanoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoradians {
    fn default() -> Self {
        UnitNanoradians
    }
}
impl Add<UnitNanoradians> for UnitNanoradians {
    type Output = UnitNanoradians;
    #[inline]
    fn add(self, _: UnitNanoradians) -> Self::Output {
        UnitNanoradians
    }
}
impl AddAssign<UnitNanoradians> for UnitNanoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoradians) {}
}
impl Sub<UnitNanoradians> for UnitNanoradians {
    type Output = UnitNanoradians;
    #[inline]
    fn sub(self, _: UnitNanoradians) -> Self::Output {
        UnitNanoradians
    }
}
impl SubAssign<UnitNanoradians> for UnitNanoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoradians) {}
}
pub struct UnitNanoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoradiansMul {
    #[inline]
    fn clone(&self) -> UnitNanoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitNanoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoradiansMul> for i8 {
    type Output = Quantity<i8, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for i16 {
    type Output = Quantity<i16, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for i32 {
    type Output = Quantity<i32, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for i64 {
    type Output = Quantity<i64, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for i128 {
    type Output = Quantity<i128, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for isize {
    type Output = Quantity<isize, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for u8 {
    type Output = Quantity<u8, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for u16 {
    type Output = Quantity<u16, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for u32 {
    type Output = Quantity<u32, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for u64 {
    type Output = Quantity<u64, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for u128 {
    type Output = Quantity<u128, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for usize {
    type Output = Quantity<usize, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for f32 {
    type Output = Quantity<f32, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
impl Mul<UnitNanoradiansMul> for f64 {
    type Output = Quantity<f64, UnitNanoradians>;
    fn mul(self, _: UnitNanoradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanoradians)
    }
}
pub struct UnitPicoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoradians {
    #[inline]
    fn clone(&self) -> UnitPicoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoradians {
    #[inline]
    fn eq(&self, other: &UnitPicoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoradians {
    fn default() -> Self {
        UnitPicoradians
    }
}
impl Add<UnitPicoradians> for UnitPicoradians {
    type Output = UnitPicoradians;
    #[inline]
    fn add(self, _: UnitPicoradians) -> Self::Output {
        UnitPicoradians
    }
}
impl AddAssign<UnitPicoradians> for UnitPicoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoradians) {}
}
impl Sub<UnitPicoradians> for UnitPicoradians {
    type Output = UnitPicoradians;
    #[inline]
    fn sub(self, _: UnitPicoradians) -> Self::Output {
        UnitPicoradians
    }
}
impl SubAssign<UnitPicoradians> for UnitPicoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoradians) {}
}
pub struct UnitPicoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoradiansMul {
    #[inline]
    fn clone(&self) -> UnitPicoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitPicoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoradiansMul> for i8 {
    type Output = Quantity<i8, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for i16 {
    type Output = Quantity<i16, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for i32 {
    type Output = Quantity<i32, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for i64 {
    type Output = Quantity<i64, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for i128 {
    type Output = Quantity<i128, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for isize {
    type Output = Quantity<isize, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for u8 {
    type Output = Quantity<u8, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for u16 {
    type Output = Quantity<u16, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for u32 {
    type Output = Quantity<u32, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for u64 {
    type Output = Quantity<u64, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for u128 {
    type Output = Quantity<u128, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for usize {
    type Output = Quantity<usize, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for f32 {
    type Output = Quantity<f32, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
impl Mul<UnitPicoradiansMul> for f64 {
    type Output = Quantity<f64, UnitPicoradians>;
    fn mul(self, _: UnitPicoradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicoradians)
    }
}
pub struct UnitFemtoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoradians {
    #[inline]
    fn clone(&self) -> UnitFemtoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoradians {
    #[inline]
    fn eq(&self, other: &UnitFemtoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoradians {
    fn default() -> Self {
        UnitFemtoradians
    }
}
impl Add<UnitFemtoradians> for UnitFemtoradians {
    type Output = UnitFemtoradians;
    #[inline]
    fn add(self, _: UnitFemtoradians) -> Self::Output {
        UnitFemtoradians
    }
}
impl AddAssign<UnitFemtoradians> for UnitFemtoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoradians) {}
}
impl Sub<UnitFemtoradians> for UnitFemtoradians {
    type Output = UnitFemtoradians;
    #[inline]
    fn sub(self, _: UnitFemtoradians) -> Self::Output {
        UnitFemtoradians
    }
}
impl SubAssign<UnitFemtoradians> for UnitFemtoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoradians) {}
}
pub struct UnitFemtoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoradiansMul {
    #[inline]
    fn clone(&self) -> UnitFemtoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoradiansMul> for i8 {
    type Output = Quantity<i8, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for i16 {
    type Output = Quantity<i16, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for i32 {
    type Output = Quantity<i32, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for i64 {
    type Output = Quantity<i64, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for i128 {
    type Output = Quantity<i128, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for isize {
    type Output = Quantity<isize, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for u8 {
    type Output = Quantity<u8, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for u16 {
    type Output = Quantity<u16, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for u32 {
    type Output = Quantity<u32, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for u64 {
    type Output = Quantity<u64, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for u128 {
    type Output = Quantity<u128, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for usize {
    type Output = Quantity<usize, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for f32 {
    type Output = Quantity<f32, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
impl Mul<UnitFemtoradiansMul> for f64 {
    type Output = Quantity<f64, UnitFemtoradians>;
    fn mul(self, _: UnitFemtoradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtoradians)
    }
}
pub struct UnitAttoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoradians {
    #[inline]
    fn clone(&self) -> UnitAttoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoradians {
    #[inline]
    fn eq(&self, other: &UnitAttoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoradians {
    fn default() -> Self {
        UnitAttoradians
    }
}
impl Add<UnitAttoradians> for UnitAttoradians {
    type Output = UnitAttoradians;
    #[inline]
    fn add(self, _: UnitAttoradians) -> Self::Output {
        UnitAttoradians
    }
}
impl AddAssign<UnitAttoradians> for UnitAttoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoradians) {}
}
impl Sub<UnitAttoradians> for UnitAttoradians {
    type Output = UnitAttoradians;
    #[inline]
    fn sub(self, _: UnitAttoradians) -> Self::Output {
        UnitAttoradians
    }
}
impl SubAssign<UnitAttoradians> for UnitAttoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoradians) {}
}
pub struct UnitAttoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoradiansMul {
    #[inline]
    fn clone(&self) -> UnitAttoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitAttoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoradiansMul> for i8 {
    type Output = Quantity<i8, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for i16 {
    type Output = Quantity<i16, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for i32 {
    type Output = Quantity<i32, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for i64 {
    type Output = Quantity<i64, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for i128 {
    type Output = Quantity<i128, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for isize {
    type Output = Quantity<isize, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for u8 {
    type Output = Quantity<u8, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for u16 {
    type Output = Quantity<u16, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for u32 {
    type Output = Quantity<u32, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for u64 {
    type Output = Quantity<u64, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for u128 {
    type Output = Quantity<u128, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for usize {
    type Output = Quantity<usize, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for f32 {
    type Output = Quantity<f32, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
impl Mul<UnitAttoradiansMul> for f64 {
    type Output = Quantity<f64, UnitAttoradians>;
    fn mul(self, _: UnitAttoradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttoradians)
    }
}
pub struct UnitZeptoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoradians {
    #[inline]
    fn clone(&self) -> UnitZeptoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoradians {
    #[inline]
    fn eq(&self, other: &UnitZeptoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoradians {
    fn default() -> Self {
        UnitZeptoradians
    }
}
impl Add<UnitZeptoradians> for UnitZeptoradians {
    type Output = UnitZeptoradians;
    #[inline]
    fn add(self, _: UnitZeptoradians) -> Self::Output {
        UnitZeptoradians
    }
}
impl AddAssign<UnitZeptoradians> for UnitZeptoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoradians) {}
}
impl Sub<UnitZeptoradians> for UnitZeptoradians {
    type Output = UnitZeptoradians;
    #[inline]
    fn sub(self, _: UnitZeptoradians) -> Self::Output {
        UnitZeptoradians
    }
}
impl SubAssign<UnitZeptoradians> for UnitZeptoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoradians) {}
}
pub struct UnitZeptoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoradiansMul {
    #[inline]
    fn clone(&self) -> UnitZeptoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoradiansMul> for i8 {
    type Output = Quantity<i8, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for i16 {
    type Output = Quantity<i16, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for i32 {
    type Output = Quantity<i32, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for i64 {
    type Output = Quantity<i64, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for i128 {
    type Output = Quantity<i128, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for isize {
    type Output = Quantity<isize, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for u8 {
    type Output = Quantity<u8, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for u16 {
    type Output = Quantity<u16, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for u32 {
    type Output = Quantity<u32, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for u64 {
    type Output = Quantity<u64, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for u128 {
    type Output = Quantity<u128, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for usize {
    type Output = Quantity<usize, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for f32 {
    type Output = Quantity<f32, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
impl Mul<UnitZeptoradiansMul> for f64 {
    type Output = Quantity<f64, UnitZeptoradians>;
    fn mul(self, _: UnitZeptoradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptoradians)
    }
}
pub struct UnitYoctoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoradians {
    #[inline]
    fn clone(&self) -> UnitYoctoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoradians {
    #[inline]
    fn eq(&self, other: &UnitYoctoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoradians {
    fn default() -> Self {
        UnitYoctoradians
    }
}
impl Add<UnitYoctoradians> for UnitYoctoradians {
    type Output = UnitYoctoradians;
    #[inline]
    fn add(self, _: UnitYoctoradians) -> Self::Output {
        UnitYoctoradians
    }
}
impl AddAssign<UnitYoctoradians> for UnitYoctoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoradians) {}
}
impl Sub<UnitYoctoradians> for UnitYoctoradians {
    type Output = UnitYoctoradians;
    #[inline]
    fn sub(self, _: UnitYoctoradians) -> Self::Output {
        UnitYoctoradians
    }
}
impl SubAssign<UnitYoctoradians> for UnitYoctoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoradians) {}
}
pub struct UnitYoctoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoradiansMul {
    #[inline]
    fn clone(&self) -> UnitYoctoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoradiansMul> for i8 {
    type Output = Quantity<i8, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for i16 {
    type Output = Quantity<i16, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for i32 {
    type Output = Quantity<i32, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for i64 {
    type Output = Quantity<i64, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for i128 {
    type Output = Quantity<i128, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for isize {
    type Output = Quantity<isize, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for u8 {
    type Output = Quantity<u8, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for u16 {
    type Output = Quantity<u16, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for u32 {
    type Output = Quantity<u32, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for u64 {
    type Output = Quantity<u64, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for u128 {
    type Output = Quantity<u128, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for usize {
    type Output = Quantity<usize, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for f32 {
    type Output = Quantity<f32, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
impl Mul<UnitYoctoradiansMul> for f64 {
    type Output = Quantity<f64, UnitYoctoradians>;
    fn mul(self, _: UnitYoctoradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctoradians)
    }
}
pub struct UnitRontoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoradians {
    #[inline]
    fn clone(&self) -> UnitRontoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoradians {
    #[inline]
    fn eq(&self, other: &UnitRontoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoradians {
    fn default() -> Self {
        UnitRontoradians
    }
}
impl Add<UnitRontoradians> for UnitRontoradians {
    type Output = UnitRontoradians;
    #[inline]
    fn add(self, _: UnitRontoradians) -> Self::Output {
        UnitRontoradians
    }
}
impl AddAssign<UnitRontoradians> for UnitRontoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoradians) {}
}
impl Sub<UnitRontoradians> for UnitRontoradians {
    type Output = UnitRontoradians;
    #[inline]
    fn sub(self, _: UnitRontoradians) -> Self::Output {
        UnitRontoradians
    }
}
impl SubAssign<UnitRontoradians> for UnitRontoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoradians) {}
}
pub struct UnitRontoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoradiansMul {
    #[inline]
    fn clone(&self) -> UnitRontoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitRontoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoradiansMul> for i8 {
    type Output = Quantity<i8, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for i16 {
    type Output = Quantity<i16, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for i32 {
    type Output = Quantity<i32, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for i64 {
    type Output = Quantity<i64, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for i128 {
    type Output = Quantity<i128, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for isize {
    type Output = Quantity<isize, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for u8 {
    type Output = Quantity<u8, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for u16 {
    type Output = Quantity<u16, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for u32 {
    type Output = Quantity<u32, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for u64 {
    type Output = Quantity<u64, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for u128 {
    type Output = Quantity<u128, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for usize {
    type Output = Quantity<usize, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for f32 {
    type Output = Quantity<f32, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
impl Mul<UnitRontoradiansMul> for f64 {
    type Output = Quantity<f64, UnitRontoradians>;
    fn mul(self, _: UnitRontoradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontoradians)
    }
}
pub struct UnitQuectoradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoradians {
    #[inline]
    fn clone(&self) -> UnitQuectoradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoradians {
    #[inline]
    fn eq(&self, other: &UnitQuectoradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoradians {
    fn default() -> Self {
        UnitQuectoradians
    }
}
impl Add<UnitQuectoradians> for UnitQuectoradians {
    type Output = UnitQuectoradians;
    #[inline]
    fn add(self, _: UnitQuectoradians) -> Self::Output {
        UnitQuectoradians
    }
}
impl AddAssign<UnitQuectoradians> for UnitQuectoradians {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoradians) {}
}
impl Sub<UnitQuectoradians> for UnitQuectoradians {
    type Output = UnitQuectoradians;
    #[inline]
    fn sub(self, _: UnitQuectoradians) -> Self::Output {
        UnitQuectoradians
    }
}
impl SubAssign<UnitQuectoradians> for UnitQuectoradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoradians) {}
}
pub struct UnitQuectoradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoradiansMul {
    #[inline]
    fn clone(&self) -> UnitQuectoradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoradiansMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoradiansMul> for i8 {
    type Output = Quantity<i8, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for i16 {
    type Output = Quantity<i16, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for i32 {
    type Output = Quantity<i32, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for i64 {
    type Output = Quantity<i64, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for i128 {
    type Output = Quantity<i128, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for isize {
    type Output = Quantity<isize, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for u8 {
    type Output = Quantity<u8, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for u16 {
    type Output = Quantity<u16, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for u32 {
    type Output = Quantity<u32, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for u64 {
    type Output = Quantity<u64, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for u128 {
    type Output = Quantity<u128, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for usize {
    type Output = Quantity<usize, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for f32 {
    type Output = Quantity<f32, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
impl Mul<UnitQuectoradiansMul> for f64 {
    type Output = Quantity<f64, UnitQuectoradians>;
    fn mul(self, _: UnitQuectoradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectoradians)
    }
}
pub type Radians<T> = Quantity<T, UnitRadians>;
#[allow(non_upper_case_globals)]
pub static Radians: UnitRadiansMul = UnitRadiansMul;
pub type Quettaradians<T> = Quantity<T, UnitQuettaradians>;
#[allow(non_upper_case_globals)]
pub static Quettaradians: UnitQuettaradiansMul = UnitQuettaradiansMul;
pub type Ronnaradians<T> = Quantity<T, UnitRonnaradians>;
#[allow(non_upper_case_globals)]
pub static Ronnaradians: UnitRonnaradiansMul = UnitRonnaradiansMul;
pub type Yottaradians<T> = Quantity<T, UnitYottaradians>;
#[allow(non_upper_case_globals)]
pub static Yottaradians: UnitYottaradiansMul = UnitYottaradiansMul;
pub type Zettaradians<T> = Quantity<T, UnitZettaradians>;
#[allow(non_upper_case_globals)]
pub static Zettaradians: UnitZettaradiansMul = UnitZettaradiansMul;
pub type Exaradians<T> = Quantity<T, UnitExaradians>;
#[allow(non_upper_case_globals)]
pub static Exaradians: UnitExaradiansMul = UnitExaradiansMul;
pub type Petaradians<T> = Quantity<T, UnitPetaradians>;
#[allow(non_upper_case_globals)]
pub static Petaradians: UnitPetaradiansMul = UnitPetaradiansMul;
pub type Teraradians<T> = Quantity<T, UnitTeraradians>;
#[allow(non_upper_case_globals)]
pub static Teraradians: UnitTeraradiansMul = UnitTeraradiansMul;
pub type Gigaradians<T> = Quantity<T, UnitGigaradians>;
#[allow(non_upper_case_globals)]
pub static Gigaradians: UnitGigaradiansMul = UnitGigaradiansMul;
pub type Megaradians<T> = Quantity<T, UnitMegaradians>;
#[allow(non_upper_case_globals)]
pub static Megaradians: UnitMegaradiansMul = UnitMegaradiansMul;
pub type Kiloradians<T> = Quantity<T, UnitKiloradians>;
#[allow(non_upper_case_globals)]
pub static Kiloradians: UnitKiloradiansMul = UnitKiloradiansMul;
pub type Hectoradians<T> = Quantity<T, UnitHectoradians>;
#[allow(non_upper_case_globals)]
pub static Hectoradians: UnitHectoradiansMul = UnitHectoradiansMul;
pub type Decaradians<T> = Quantity<T, UnitDecaradians>;
#[allow(non_upper_case_globals)]
pub static Decaradians: UnitDecaradiansMul = UnitDecaradiansMul;
pub type Deciradians<T> = Quantity<T, UnitDeciradians>;
#[allow(non_upper_case_globals)]
pub static Deciradians: UnitDeciradiansMul = UnitDeciradiansMul;
pub type Centiradians<T> = Quantity<T, UnitCentiradians>;
#[allow(non_upper_case_globals)]
pub static Centiradians: UnitCentiradiansMul = UnitCentiradiansMul;
pub type Milliradians<T> = Quantity<T, UnitMilliradians>;
#[allow(non_upper_case_globals)]
pub static Milliradians: UnitMilliradiansMul = UnitMilliradiansMul;
pub type Microradians<T> = Quantity<T, UnitMicroradians>;
#[allow(non_upper_case_globals)]
pub static Microradians: UnitMicroradiansMul = UnitMicroradiansMul;
pub type Nanoradians<T> = Quantity<T, UnitNanoradians>;
#[allow(non_upper_case_globals)]
pub static Nanoradians: UnitNanoradiansMul = UnitNanoradiansMul;
pub type Picoradians<T> = Quantity<T, UnitPicoradians>;
#[allow(non_upper_case_globals)]
pub static Picoradians: UnitPicoradiansMul = UnitPicoradiansMul;
pub type Femtoradians<T> = Quantity<T, UnitFemtoradians>;
#[allow(non_upper_case_globals)]
pub static Femtoradians: UnitFemtoradiansMul = UnitFemtoradiansMul;
pub type Attoradians<T> = Quantity<T, UnitAttoradians>;
#[allow(non_upper_case_globals)]
pub static Attoradians: UnitAttoradiansMul = UnitAttoradiansMul;
pub type Zeptoradians<T> = Quantity<T, UnitZeptoradians>;
#[allow(non_upper_case_globals)]
pub static Zeptoradians: UnitZeptoradiansMul = UnitZeptoradiansMul;
pub type Yoctoradians<T> = Quantity<T, UnitYoctoradians>;
#[allow(non_upper_case_globals)]
pub static Yoctoradians: UnitYoctoradiansMul = UnitYoctoradiansMul;
pub type Rontoradians<T> = Quantity<T, UnitRontoradians>;
#[allow(non_upper_case_globals)]
pub static Rontoradians: UnitRontoradiansMul = UnitRontoradiansMul;
pub type Quectoradians<T> = Quantity<T, UnitQuectoradians>;
#[allow(non_upper_case_globals)]
pub static Quectoradians: UnitQuectoradiansMul = UnitQuectoradiansMul;
pub struct UnitSteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSteradians {
    #[inline]
    fn clone(&self) -> UnitSteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSteradians {
    #[inline]
    fn eq(&self, other: &UnitSteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitSteradians {
    fn default() -> Self {
        UnitSteradians
    }
}
impl Add<UnitSteradians> for UnitSteradians {
    type Output = UnitSteradians;
    #[inline]
    fn add(self, _: UnitSteradians) -> Self::Output {
        UnitSteradians
    }
}
impl AddAssign<UnitSteradians> for UnitSteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitSteradians) {}
}
impl Sub<UnitSteradians> for UnitSteradians {
    type Output = UnitSteradians;
    #[inline]
    fn sub(self, _: UnitSteradians) -> Self::Output {
        UnitSteradians
    }
}
impl SubAssign<UnitSteradians> for UnitSteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitSteradians) {}
}
pub struct UnitSteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSteradiansMul {
    #[inline]
    fn clone(&self) -> UnitSteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitSteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitSteradiansMul> for i8 {
    type Output = Quantity<i8, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for i16 {
    type Output = Quantity<i16, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for i32 {
    type Output = Quantity<i32, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for i64 {
    type Output = Quantity<i64, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for i128 {
    type Output = Quantity<i128, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for isize {
    type Output = Quantity<isize, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for u8 {
    type Output = Quantity<u8, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for u16 {
    type Output = Quantity<u16, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for u32 {
    type Output = Quantity<u32, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for u64 {
    type Output = Quantity<u64, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for u128 {
    type Output = Quantity<u128, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for usize {
    type Output = Quantity<usize, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for f32 {
    type Output = Quantity<f32, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
impl Mul<UnitSteradiansMul> for f64 {
    type Output = Quantity<f64, UnitSteradians>;
    fn mul(self, _: UnitSteradiansMul) -> Self::Output {
        Quantity::new(self, UnitSteradians)
    }
}
pub struct UnitQuettasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasteradians {
    #[inline]
    fn clone(&self) -> UnitQuettasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasteradians {
    #[inline]
    fn eq(&self, other: &UnitQuettasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettasteradians {
    fn default() -> Self {
        UnitQuettasteradians
    }
}
impl Add<UnitQuettasteradians> for UnitQuettasteradians {
    type Output = UnitQuettasteradians;
    #[inline]
    fn add(self, _: UnitQuettasteradians) -> Self::Output {
        UnitQuettasteradians
    }
}
impl AddAssign<UnitQuettasteradians> for UnitQuettasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettasteradians) {}
}
impl Sub<UnitQuettasteradians> for UnitQuettasteradians {
    type Output = UnitQuettasteradians;
    #[inline]
    fn sub(self, _: UnitQuettasteradians) -> Self::Output {
        UnitQuettasteradians
    }
}
impl SubAssign<UnitQuettasteradians> for UnitQuettasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettasteradians) {}
}
pub struct UnitQuettasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitQuettasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitQuettasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for isize {
    type Output = Quantity<isize, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for usize {
    type Output = Quantity<usize, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
impl Mul<UnitQuettasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitQuettasteradians>;
    fn mul(self, _: UnitQuettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuettasteradians)
    }
}
pub struct UnitRonnasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasteradians {
    #[inline]
    fn clone(&self) -> UnitRonnasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasteradians {
    #[inline]
    fn eq(&self, other: &UnitRonnasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnasteradians {
    fn default() -> Self {
        UnitRonnasteradians
    }
}
impl Add<UnitRonnasteradians> for UnitRonnasteradians {
    type Output = UnitRonnasteradians;
    #[inline]
    fn add(self, _: UnitRonnasteradians) -> Self::Output {
        UnitRonnasteradians
    }
}
impl AddAssign<UnitRonnasteradians> for UnitRonnasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnasteradians) {}
}
impl Sub<UnitRonnasteradians> for UnitRonnasteradians {
    type Output = UnitRonnasteradians;
    #[inline]
    fn sub(self, _: UnitRonnasteradians) -> Self::Output {
        UnitRonnasteradians
    }
}
impl SubAssign<UnitRonnasteradians> for UnitRonnasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnasteradians) {}
}
pub struct UnitRonnasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitRonnasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitRonnasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for isize {
    type Output = Quantity<isize, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for usize {
    type Output = Quantity<usize, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
impl Mul<UnitRonnasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitRonnasteradians>;
    fn mul(self, _: UnitRonnasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRonnasteradians)
    }
}
pub struct UnitYottasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasteradians {
    #[inline]
    fn clone(&self) -> UnitYottasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasteradians {
    #[inline]
    fn eq(&self, other: &UnitYottasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottasteradians {
    fn default() -> Self {
        UnitYottasteradians
    }
}
impl Add<UnitYottasteradians> for UnitYottasteradians {
    type Output = UnitYottasteradians;
    #[inline]
    fn add(self, _: UnitYottasteradians) -> Self::Output {
        UnitYottasteradians
    }
}
impl AddAssign<UnitYottasteradians> for UnitYottasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitYottasteradians) {}
}
impl Sub<UnitYottasteradians> for UnitYottasteradians {
    type Output = UnitYottasteradians;
    #[inline]
    fn sub(self, _: UnitYottasteradians) -> Self::Output {
        UnitYottasteradians
    }
}
impl SubAssign<UnitYottasteradians> for UnitYottasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottasteradians) {}
}
pub struct UnitYottasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitYottasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitYottasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for isize {
    type Output = Quantity<isize, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for usize {
    type Output = Quantity<usize, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
impl Mul<UnitYottasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitYottasteradians>;
    fn mul(self, _: UnitYottasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYottasteradians)
    }
}
pub struct UnitZettasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasteradians {
    #[inline]
    fn clone(&self) -> UnitZettasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasteradians {
    #[inline]
    fn eq(&self, other: &UnitZettasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettasteradians {
    fn default() -> Self {
        UnitZettasteradians
    }
}
impl Add<UnitZettasteradians> for UnitZettasteradians {
    type Output = UnitZettasteradians;
    #[inline]
    fn add(self, _: UnitZettasteradians) -> Self::Output {
        UnitZettasteradians
    }
}
impl AddAssign<UnitZettasteradians> for UnitZettasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitZettasteradians) {}
}
impl Sub<UnitZettasteradians> for UnitZettasteradians {
    type Output = UnitZettasteradians;
    #[inline]
    fn sub(self, _: UnitZettasteradians) -> Self::Output {
        UnitZettasteradians
    }
}
impl SubAssign<UnitZettasteradians> for UnitZettasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettasteradians) {}
}
pub struct UnitZettasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitZettasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitZettasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for isize {
    type Output = Quantity<isize, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for usize {
    type Output = Quantity<usize, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
impl Mul<UnitZettasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitZettasteradians>;
    fn mul(self, _: UnitZettasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZettasteradians)
    }
}
pub struct UnitExasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasteradians {
    #[inline]
    fn clone(&self) -> UnitExasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasteradians {
    #[inline]
    fn eq(&self, other: &UnitExasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExasteradians {
    fn default() -> Self {
        UnitExasteradians
    }
}
impl Add<UnitExasteradians> for UnitExasteradians {
    type Output = UnitExasteradians;
    #[inline]
    fn add(self, _: UnitExasteradians) -> Self::Output {
        UnitExasteradians
    }
}
impl AddAssign<UnitExasteradians> for UnitExasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitExasteradians) {}
}
impl Sub<UnitExasteradians> for UnitExasteradians {
    type Output = UnitExasteradians;
    #[inline]
    fn sub(self, _: UnitExasteradians) -> Self::Output {
        UnitExasteradians
    }
}
impl SubAssign<UnitExasteradians> for UnitExasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitExasteradians) {}
}
pub struct UnitExasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitExasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitExasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for isize {
    type Output = Quantity<isize, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for usize {
    type Output = Quantity<usize, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
impl Mul<UnitExasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitExasteradians>;
    fn mul(self, _: UnitExasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitExasteradians)
    }
}
pub struct UnitPetasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasteradians {
    #[inline]
    fn clone(&self) -> UnitPetasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasteradians {
    #[inline]
    fn eq(&self, other: &UnitPetasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetasteradians {
    fn default() -> Self {
        UnitPetasteradians
    }
}
impl Add<UnitPetasteradians> for UnitPetasteradians {
    type Output = UnitPetasteradians;
    #[inline]
    fn add(self, _: UnitPetasteradians) -> Self::Output {
        UnitPetasteradians
    }
}
impl AddAssign<UnitPetasteradians> for UnitPetasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitPetasteradians) {}
}
impl Sub<UnitPetasteradians> for UnitPetasteradians {
    type Output = UnitPetasteradians;
    #[inline]
    fn sub(self, _: UnitPetasteradians) -> Self::Output {
        UnitPetasteradians
    }
}
impl SubAssign<UnitPetasteradians> for UnitPetasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetasteradians) {}
}
pub struct UnitPetasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitPetasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitPetasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for isize {
    type Output = Quantity<isize, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for usize {
    type Output = Quantity<usize, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
impl Mul<UnitPetasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitPetasteradians>;
    fn mul(self, _: UnitPetasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPetasteradians)
    }
}
pub struct UnitTerasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasteradians {
    #[inline]
    fn clone(&self) -> UnitTerasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasteradians {
    #[inline]
    fn eq(&self, other: &UnitTerasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerasteradians {
    fn default() -> Self {
        UnitTerasteradians
    }
}
impl Add<UnitTerasteradians> for UnitTerasteradians {
    type Output = UnitTerasteradians;
    #[inline]
    fn add(self, _: UnitTerasteradians) -> Self::Output {
        UnitTerasteradians
    }
}
impl AddAssign<UnitTerasteradians> for UnitTerasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitTerasteradians) {}
}
impl Sub<UnitTerasteradians> for UnitTerasteradians {
    type Output = UnitTerasteradians;
    #[inline]
    fn sub(self, _: UnitTerasteradians) -> Self::Output {
        UnitTerasteradians
    }
}
impl SubAssign<UnitTerasteradians> for UnitTerasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerasteradians) {}
}
pub struct UnitTerasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitTerasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitTerasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for isize {
    type Output = Quantity<isize, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for usize {
    type Output = Quantity<usize, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
impl Mul<UnitTerasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitTerasteradians>;
    fn mul(self, _: UnitTerasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitTerasteradians)
    }
}
pub struct UnitGigasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasteradians {
    #[inline]
    fn clone(&self) -> UnitGigasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasteradians {
    #[inline]
    fn eq(&self, other: &UnitGigasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigasteradians {
    fn default() -> Self {
        UnitGigasteradians
    }
}
impl Add<UnitGigasteradians> for UnitGigasteradians {
    type Output = UnitGigasteradians;
    #[inline]
    fn add(self, _: UnitGigasteradians) -> Self::Output {
        UnitGigasteradians
    }
}
impl AddAssign<UnitGigasteradians> for UnitGigasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitGigasteradians) {}
}
impl Sub<UnitGigasteradians> for UnitGigasteradians {
    type Output = UnitGigasteradians;
    #[inline]
    fn sub(self, _: UnitGigasteradians) -> Self::Output {
        UnitGigasteradians
    }
}
impl SubAssign<UnitGigasteradians> for UnitGigasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigasteradians) {}
}
pub struct UnitGigasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitGigasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitGigasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for isize {
    type Output = Quantity<isize, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for usize {
    type Output = Quantity<usize, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
impl Mul<UnitGigasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitGigasteradians>;
    fn mul(self, _: UnitGigasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitGigasteradians)
    }
}
pub struct UnitMegasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasteradians {
    #[inline]
    fn clone(&self) -> UnitMegasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasteradians {
    #[inline]
    fn eq(&self, other: &UnitMegasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegasteradians {
    fn default() -> Self {
        UnitMegasteradians
    }
}
impl Add<UnitMegasteradians> for UnitMegasteradians {
    type Output = UnitMegasteradians;
    #[inline]
    fn add(self, _: UnitMegasteradians) -> Self::Output {
        UnitMegasteradians
    }
}
impl AddAssign<UnitMegasteradians> for UnitMegasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMegasteradians) {}
}
impl Sub<UnitMegasteradians> for UnitMegasteradians {
    type Output = UnitMegasteradians;
    #[inline]
    fn sub(self, _: UnitMegasteradians) -> Self::Output {
        UnitMegasteradians
    }
}
impl SubAssign<UnitMegasteradians> for UnitMegasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegasteradians) {}
}
pub struct UnitMegasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitMegasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMegasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for isize {
    type Output = Quantity<isize, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for usize {
    type Output = Quantity<usize, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
impl Mul<UnitMegasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitMegasteradians>;
    fn mul(self, _: UnitMegasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMegasteradians)
    }
}
pub struct UnitKilosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosteradians {
    #[inline]
    fn clone(&self) -> UnitKilosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosteradians {
    #[inline]
    fn eq(&self, other: &UnitKilosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilosteradians {
    fn default() -> Self {
        UnitKilosteradians
    }
}
impl Add<UnitKilosteradians> for UnitKilosteradians {
    type Output = UnitKilosteradians;
    #[inline]
    fn add(self, _: UnitKilosteradians) -> Self::Output {
        UnitKilosteradians
    }
}
impl AddAssign<UnitKilosteradians> for UnitKilosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitKilosteradians) {}
}
impl Sub<UnitKilosteradians> for UnitKilosteradians {
    type Output = UnitKilosteradians;
    #[inline]
    fn sub(self, _: UnitKilosteradians) -> Self::Output {
        UnitKilosteradians
    }
}
impl SubAssign<UnitKilosteradians> for UnitKilosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilosteradians) {}
}
pub struct UnitKilosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitKilosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitKilosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for isize {
    type Output = Quantity<isize, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for usize {
    type Output = Quantity<usize, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
impl Mul<UnitKilosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitKilosteradians>;
    fn mul(self, _: UnitKilosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitKilosteradians)
    }
}
pub struct UnitHectosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosteradians {
    #[inline]
    fn clone(&self) -> UnitHectosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosteradians {
    #[inline]
    fn eq(&self, other: &UnitHectosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectosteradians {
    fn default() -> Self {
        UnitHectosteradians
    }
}
impl Add<UnitHectosteradians> for UnitHectosteradians {
    type Output = UnitHectosteradians;
    #[inline]
    fn add(self, _: UnitHectosteradians) -> Self::Output {
        UnitHectosteradians
    }
}
impl AddAssign<UnitHectosteradians> for UnitHectosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitHectosteradians) {}
}
impl Sub<UnitHectosteradians> for UnitHectosteradians {
    type Output = UnitHectosteradians;
    #[inline]
    fn sub(self, _: UnitHectosteradians) -> Self::Output {
        UnitHectosteradians
    }
}
impl SubAssign<UnitHectosteradians> for UnitHectosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectosteradians) {}
}
pub struct UnitHectosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitHectosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitHectosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for isize {
    type Output = Quantity<isize, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for usize {
    type Output = Quantity<usize, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
impl Mul<UnitHectosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitHectosteradians>;
    fn mul(self, _: UnitHectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitHectosteradians)
    }
}
pub struct UnitDecasteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasteradians {
    #[inline]
    fn clone(&self) -> UnitDecasteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasteradians {
    #[inline]
    fn eq(&self, other: &UnitDecasteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecasteradians {
    fn default() -> Self {
        UnitDecasteradians
    }
}
impl Add<UnitDecasteradians> for UnitDecasteradians {
    type Output = UnitDecasteradians;
    #[inline]
    fn add(self, _: UnitDecasteradians) -> Self::Output {
        UnitDecasteradians
    }
}
impl AddAssign<UnitDecasteradians> for UnitDecasteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitDecasteradians) {}
}
impl Sub<UnitDecasteradians> for UnitDecasteradians {
    type Output = UnitDecasteradians;
    #[inline]
    fn sub(self, _: UnitDecasteradians) -> Self::Output {
        UnitDecasteradians
    }
}
impl SubAssign<UnitDecasteradians> for UnitDecasteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecasteradians) {}
}
pub struct UnitDecasteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasteradiansMul {
    #[inline]
    fn clone(&self) -> UnitDecasteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitDecasteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecasteradiansMul> for i8 {
    type Output = Quantity<i8, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for i16 {
    type Output = Quantity<i16, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for i32 {
    type Output = Quantity<i32, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for i64 {
    type Output = Quantity<i64, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for i128 {
    type Output = Quantity<i128, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for isize {
    type Output = Quantity<isize, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for u8 {
    type Output = Quantity<u8, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for u16 {
    type Output = Quantity<u16, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for u32 {
    type Output = Quantity<u32, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for u64 {
    type Output = Quantity<u64, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for u128 {
    type Output = Quantity<u128, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for usize {
    type Output = Quantity<usize, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for f32 {
    type Output = Quantity<f32, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
impl Mul<UnitDecasteradiansMul> for f64 {
    type Output = Quantity<f64, UnitDecasteradians>;
    fn mul(self, _: UnitDecasteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecasteradians)
    }
}
pub struct UnitDecisteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisteradians {
    #[inline]
    fn clone(&self) -> UnitDecisteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisteradians {
    #[inline]
    fn eq(&self, other: &UnitDecisteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecisteradians {
    fn default() -> Self {
        UnitDecisteradians
    }
}
impl Add<UnitDecisteradians> for UnitDecisteradians {
    type Output = UnitDecisteradians;
    #[inline]
    fn add(self, _: UnitDecisteradians) -> Self::Output {
        UnitDecisteradians
    }
}
impl AddAssign<UnitDecisteradians> for UnitDecisteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitDecisteradians) {}
}
impl Sub<UnitDecisteradians> for UnitDecisteradians {
    type Output = UnitDecisteradians;
    #[inline]
    fn sub(self, _: UnitDecisteradians) -> Self::Output {
        UnitDecisteradians
    }
}
impl SubAssign<UnitDecisteradians> for UnitDecisteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecisteradians) {}
}
pub struct UnitDecisteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisteradiansMul {
    #[inline]
    fn clone(&self) -> UnitDecisteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitDecisteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecisteradiansMul> for i8 {
    type Output = Quantity<i8, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for i16 {
    type Output = Quantity<i16, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for i32 {
    type Output = Quantity<i32, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for i64 {
    type Output = Quantity<i64, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for i128 {
    type Output = Quantity<i128, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for isize {
    type Output = Quantity<isize, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for u8 {
    type Output = Quantity<u8, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for u16 {
    type Output = Quantity<u16, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for u32 {
    type Output = Quantity<u32, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for u64 {
    type Output = Quantity<u64, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for u128 {
    type Output = Quantity<u128, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for usize {
    type Output = Quantity<usize, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for f32 {
    type Output = Quantity<f32, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
impl Mul<UnitDecisteradiansMul> for f64 {
    type Output = Quantity<f64, UnitDecisteradians>;
    fn mul(self, _: UnitDecisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitDecisteradians)
    }
}
pub struct UnitCentisteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisteradians {
    #[inline]
    fn clone(&self) -> UnitCentisteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisteradians {
    #[inline]
    fn eq(&self, other: &UnitCentisteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentisteradians {
    fn default() -> Self {
        UnitCentisteradians
    }
}
impl Add<UnitCentisteradians> for UnitCentisteradians {
    type Output = UnitCentisteradians;
    #[inline]
    fn add(self, _: UnitCentisteradians) -> Self::Output {
        UnitCentisteradians
    }
}
impl AddAssign<UnitCentisteradians> for UnitCentisteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitCentisteradians) {}
}
impl Sub<UnitCentisteradians> for UnitCentisteradians {
    type Output = UnitCentisteradians;
    #[inline]
    fn sub(self, _: UnitCentisteradians) -> Self::Output {
        UnitCentisteradians
    }
}
impl SubAssign<UnitCentisteradians> for UnitCentisteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentisteradians) {}
}
pub struct UnitCentisteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisteradiansMul {
    #[inline]
    fn clone(&self) -> UnitCentisteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitCentisteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentisteradiansMul> for i8 {
    type Output = Quantity<i8, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for i16 {
    type Output = Quantity<i16, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for i32 {
    type Output = Quantity<i32, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for i64 {
    type Output = Quantity<i64, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for i128 {
    type Output = Quantity<i128, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for isize {
    type Output = Quantity<isize, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for u8 {
    type Output = Quantity<u8, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for u16 {
    type Output = Quantity<u16, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for u32 {
    type Output = Quantity<u32, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for u64 {
    type Output = Quantity<u64, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for u128 {
    type Output = Quantity<u128, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for usize {
    type Output = Quantity<usize, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for f32 {
    type Output = Quantity<f32, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
impl Mul<UnitCentisteradiansMul> for f64 {
    type Output = Quantity<f64, UnitCentisteradians>;
    fn mul(self, _: UnitCentisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitCentisteradians)
    }
}
pub struct UnitMillisteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisteradians {
    #[inline]
    fn clone(&self) -> UnitMillisteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisteradians {
    #[inline]
    fn eq(&self, other: &UnitMillisteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillisteradians {
    fn default() -> Self {
        UnitMillisteradians
    }
}
impl Add<UnitMillisteradians> for UnitMillisteradians {
    type Output = UnitMillisteradians;
    #[inline]
    fn add(self, _: UnitMillisteradians) -> Self::Output {
        UnitMillisteradians
    }
}
impl AddAssign<UnitMillisteradians> for UnitMillisteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMillisteradians) {}
}
impl Sub<UnitMillisteradians> for UnitMillisteradians {
    type Output = UnitMillisteradians;
    #[inline]
    fn sub(self, _: UnitMillisteradians) -> Self::Output {
        UnitMillisteradians
    }
}
impl SubAssign<UnitMillisteradians> for UnitMillisteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillisteradians) {}
}
pub struct UnitMillisteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisteradiansMul {
    #[inline]
    fn clone(&self) -> UnitMillisteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMillisteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillisteradiansMul> for i8 {
    type Output = Quantity<i8, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for i16 {
    type Output = Quantity<i16, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for i32 {
    type Output = Quantity<i32, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for i64 {
    type Output = Quantity<i64, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for i128 {
    type Output = Quantity<i128, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for isize {
    type Output = Quantity<isize, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for u8 {
    type Output = Quantity<u8, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for u16 {
    type Output = Quantity<u16, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for u32 {
    type Output = Quantity<u32, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for u64 {
    type Output = Quantity<u64, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for u128 {
    type Output = Quantity<u128, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for usize {
    type Output = Quantity<usize, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for f32 {
    type Output = Quantity<f32, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
impl Mul<UnitMillisteradiansMul> for f64 {
    type Output = Quantity<f64, UnitMillisteradians>;
    fn mul(self, _: UnitMillisteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMillisteradians)
    }
}
pub struct UnitMicrosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosteradians {
    #[inline]
    fn clone(&self) -> UnitMicrosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosteradians {
    #[inline]
    fn eq(&self, other: &UnitMicrosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrosteradians {
    fn default() -> Self {
        UnitMicrosteradians
    }
}
impl Add<UnitMicrosteradians> for UnitMicrosteradians {
    type Output = UnitMicrosteradians;
    #[inline]
    fn add(self, _: UnitMicrosteradians) -> Self::Output {
        UnitMicrosteradians
    }
}
impl AddAssign<UnitMicrosteradians> for UnitMicrosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrosteradians) {}
}
impl Sub<UnitMicrosteradians> for UnitMicrosteradians {
    type Output = UnitMicrosteradians;
    #[inline]
    fn sub(self, _: UnitMicrosteradians) -> Self::Output {
        UnitMicrosteradians
    }
}
impl SubAssign<UnitMicrosteradians> for UnitMicrosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrosteradians) {}
}
pub struct UnitMicrosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitMicrosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitMicrosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for isize {
    type Output = Quantity<isize, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for usize {
    type Output = Quantity<usize, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
impl Mul<UnitMicrosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitMicrosteradians>;
    fn mul(self, _: UnitMicrosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitMicrosteradians)
    }
}
pub struct UnitNanosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosteradians {
    #[inline]
    fn clone(&self) -> UnitNanosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosteradians {
    #[inline]
    fn eq(&self, other: &UnitNanosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanosteradians {
    fn default() -> Self {
        UnitNanosteradians
    }
}
impl Add<UnitNanosteradians> for UnitNanosteradians {
    type Output = UnitNanosteradians;
    #[inline]
    fn add(self, _: UnitNanosteradians) -> Self::Output {
        UnitNanosteradians
    }
}
impl AddAssign<UnitNanosteradians> for UnitNanosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitNanosteradians) {}
}
impl Sub<UnitNanosteradians> for UnitNanosteradians {
    type Output = UnitNanosteradians;
    #[inline]
    fn sub(self, _: UnitNanosteradians) -> Self::Output {
        UnitNanosteradians
    }
}
impl SubAssign<UnitNanosteradians> for UnitNanosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanosteradians) {}
}
pub struct UnitNanosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitNanosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitNanosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for isize {
    type Output = Quantity<isize, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for usize {
    type Output = Quantity<usize, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
impl Mul<UnitNanosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitNanosteradians>;
    fn mul(self, _: UnitNanosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitNanosteradians)
    }
}
pub struct UnitPicosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosteradians {
    #[inline]
    fn clone(&self) -> UnitPicosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosteradians {
    #[inline]
    fn eq(&self, other: &UnitPicosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicosteradians {
    fn default() -> Self {
        UnitPicosteradians
    }
}
impl Add<UnitPicosteradians> for UnitPicosteradians {
    type Output = UnitPicosteradians;
    #[inline]
    fn add(self, _: UnitPicosteradians) -> Self::Output {
        UnitPicosteradians
    }
}
impl AddAssign<UnitPicosteradians> for UnitPicosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitPicosteradians) {}
}
impl Sub<UnitPicosteradians> for UnitPicosteradians {
    type Output = UnitPicosteradians;
    #[inline]
    fn sub(self, _: UnitPicosteradians) -> Self::Output {
        UnitPicosteradians
    }
}
impl SubAssign<UnitPicosteradians> for UnitPicosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicosteradians) {}
}
pub struct UnitPicosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitPicosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitPicosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for isize {
    type Output = Quantity<isize, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for usize {
    type Output = Quantity<usize, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
impl Mul<UnitPicosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitPicosteradians>;
    fn mul(self, _: UnitPicosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitPicosteradians)
    }
}
pub struct UnitFemtosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosteradians {
    #[inline]
    fn clone(&self) -> UnitFemtosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosteradians {
    #[inline]
    fn eq(&self, other: &UnitFemtosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtosteradians {
    fn default() -> Self {
        UnitFemtosteradians
    }
}
impl Add<UnitFemtosteradians> for UnitFemtosteradians {
    type Output = UnitFemtosteradians;
    #[inline]
    fn add(self, _: UnitFemtosteradians) -> Self::Output {
        UnitFemtosteradians
    }
}
impl AddAssign<UnitFemtosteradians> for UnitFemtosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtosteradians) {}
}
impl Sub<UnitFemtosteradians> for UnitFemtosteradians {
    type Output = UnitFemtosteradians;
    #[inline]
    fn sub(self, _: UnitFemtosteradians) -> Self::Output {
        UnitFemtosteradians
    }
}
impl SubAssign<UnitFemtosteradians> for UnitFemtosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtosteradians) {}
}
pub struct UnitFemtosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitFemtosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitFemtosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for isize {
    type Output = Quantity<isize, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for usize {
    type Output = Quantity<usize, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
impl Mul<UnitFemtosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitFemtosteradians>;
    fn mul(self, _: UnitFemtosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitFemtosteradians)
    }
}
pub struct UnitAttosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosteradians {
    #[inline]
    fn clone(&self) -> UnitAttosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosteradians {
    #[inline]
    fn eq(&self, other: &UnitAttosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttosteradians {
    fn default() -> Self {
        UnitAttosteradians
    }
}
impl Add<UnitAttosteradians> for UnitAttosteradians {
    type Output = UnitAttosteradians;
    #[inline]
    fn add(self, _: UnitAttosteradians) -> Self::Output {
        UnitAttosteradians
    }
}
impl AddAssign<UnitAttosteradians> for UnitAttosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitAttosteradians) {}
}
impl Sub<UnitAttosteradians> for UnitAttosteradians {
    type Output = UnitAttosteradians;
    #[inline]
    fn sub(self, _: UnitAttosteradians) -> Self::Output {
        UnitAttosteradians
    }
}
impl SubAssign<UnitAttosteradians> for UnitAttosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttosteradians) {}
}
pub struct UnitAttosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitAttosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitAttosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for isize {
    type Output = Quantity<isize, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for usize {
    type Output = Quantity<usize, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
impl Mul<UnitAttosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitAttosteradians>;
    fn mul(self, _: UnitAttosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitAttosteradians)
    }
}
pub struct UnitZeptosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosteradians {
    #[inline]
    fn clone(&self) -> UnitZeptosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosteradians {
    #[inline]
    fn eq(&self, other: &UnitZeptosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptosteradians {
    fn default() -> Self {
        UnitZeptosteradians
    }
}
impl Add<UnitZeptosteradians> for UnitZeptosteradians {
    type Output = UnitZeptosteradians;
    #[inline]
    fn add(self, _: UnitZeptosteradians) -> Self::Output {
        UnitZeptosteradians
    }
}
impl AddAssign<UnitZeptosteradians> for UnitZeptosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptosteradians) {}
}
impl Sub<UnitZeptosteradians> for UnitZeptosteradians {
    type Output = UnitZeptosteradians;
    #[inline]
    fn sub(self, _: UnitZeptosteradians) -> Self::Output {
        UnitZeptosteradians
    }
}
impl SubAssign<UnitZeptosteradians> for UnitZeptosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptosteradians) {}
}
pub struct UnitZeptosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitZeptosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitZeptosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for isize {
    type Output = Quantity<isize, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for usize {
    type Output = Quantity<usize, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
impl Mul<UnitZeptosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitZeptosteradians>;
    fn mul(self, _: UnitZeptosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitZeptosteradians)
    }
}
pub struct UnitYoctosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosteradians {
    #[inline]
    fn clone(&self) -> UnitYoctosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosteradians {
    #[inline]
    fn eq(&self, other: &UnitYoctosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctosteradians {
    fn default() -> Self {
        UnitYoctosteradians
    }
}
impl Add<UnitYoctosteradians> for UnitYoctosteradians {
    type Output = UnitYoctosteradians;
    #[inline]
    fn add(self, _: UnitYoctosteradians) -> Self::Output {
        UnitYoctosteradians
    }
}
impl AddAssign<UnitYoctosteradians> for UnitYoctosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctosteradians) {}
}
impl Sub<UnitYoctosteradians> for UnitYoctosteradians {
    type Output = UnitYoctosteradians;
    #[inline]
    fn sub(self, _: UnitYoctosteradians) -> Self::Output {
        UnitYoctosteradians
    }
}
impl SubAssign<UnitYoctosteradians> for UnitYoctosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctosteradians) {}
}
pub struct UnitYoctosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitYoctosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitYoctosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for isize {
    type Output = Quantity<isize, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for usize {
    type Output = Quantity<usize, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
impl Mul<UnitYoctosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitYoctosteradians>;
    fn mul(self, _: UnitYoctosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitYoctosteradians)
    }
}
pub struct UnitRontosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosteradians {
    #[inline]
    fn clone(&self) -> UnitRontosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosteradians {
    #[inline]
    fn eq(&self, other: &UnitRontosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontosteradians {
    fn default() -> Self {
        UnitRontosteradians
    }
}
impl Add<UnitRontosteradians> for UnitRontosteradians {
    type Output = UnitRontosteradians;
    #[inline]
    fn add(self, _: UnitRontosteradians) -> Self::Output {
        UnitRontosteradians
    }
}
impl AddAssign<UnitRontosteradians> for UnitRontosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitRontosteradians) {}
}
impl Sub<UnitRontosteradians> for UnitRontosteradians {
    type Output = UnitRontosteradians;
    #[inline]
    fn sub(self, _: UnitRontosteradians) -> Self::Output {
        UnitRontosteradians
    }
}
impl SubAssign<UnitRontosteradians> for UnitRontosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontosteradians) {}
}
pub struct UnitRontosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitRontosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitRontosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for isize {
    type Output = Quantity<isize, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for usize {
    type Output = Quantity<usize, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
impl Mul<UnitRontosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitRontosteradians>;
    fn mul(self, _: UnitRontosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitRontosteradians)
    }
}
pub struct UnitQuectosteradians;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosteradians {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosteradians")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosteradians {
    #[inline]
    fn clone(&self) -> UnitQuectosteradians {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosteradians {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosteradians {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosteradians {
    #[inline]
    fn eq(&self, other: &UnitQuectosteradians) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosteradians {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectosteradians {
    fn default() -> Self {
        UnitQuectosteradians
    }
}
impl Add<UnitQuectosteradians> for UnitQuectosteradians {
    type Output = UnitQuectosteradians;
    #[inline]
    fn add(self, _: UnitQuectosteradians) -> Self::Output {
        UnitQuectosteradians
    }
}
impl AddAssign<UnitQuectosteradians> for UnitQuectosteradians {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectosteradians) {}
}
impl Sub<UnitQuectosteradians> for UnitQuectosteradians {
    type Output = UnitQuectosteradians;
    #[inline]
    fn sub(self, _: UnitQuectosteradians) -> Self::Output {
        UnitQuectosteradians
    }
}
impl SubAssign<UnitQuectosteradians> for UnitQuectosteradians {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectosteradians) {}
}
pub struct UnitQuectosteradiansMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosteradiansMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosteradiansMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosteradiansMul {
    #[inline]
    fn clone(&self) -> UnitQuectosteradiansMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosteradiansMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosteradiansMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosteradiansMul {
    #[inline]
    fn eq(&self, other: &UnitQuectosteradiansMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosteradiansMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectosteradiansMul> for i8 {
    type Output = Quantity<i8, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for i16 {
    type Output = Quantity<i16, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for i32 {
    type Output = Quantity<i32, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for i64 {
    type Output = Quantity<i64, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for i128 {
    type Output = Quantity<i128, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for isize {
    type Output = Quantity<isize, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for u8 {
    type Output = Quantity<u8, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for u16 {
    type Output = Quantity<u16, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for u32 {
    type Output = Quantity<u32, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for u64 {
    type Output = Quantity<u64, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for u128 {
    type Output = Quantity<u128, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for usize {
    type Output = Quantity<usize, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for f32 {
    type Output = Quantity<f32, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
impl Mul<UnitQuectosteradiansMul> for f64 {
    type Output = Quantity<f64, UnitQuectosteradians>;
    fn mul(self, _: UnitQuectosteradiansMul) -> Self::Output {
        Quantity::new(self, UnitQuectosteradians)
    }
}
pub type Steradians<T> = Quantity<T, UnitSteradians>;
#[allow(non_upper_case_globals)]
pub static Steradians: UnitSteradiansMul = UnitSteradiansMul;
pub type Quettasteradians<T> = Quantity<T, UnitQuettasteradians>;
#[allow(non_upper_case_globals)]
pub static Quettasteradians: UnitQuettasteradiansMul = UnitQuettasteradiansMul;
pub type Ronnasteradians<T> = Quantity<T, UnitRonnasteradians>;
#[allow(non_upper_case_globals)]
pub static Ronnasteradians: UnitRonnasteradiansMul = UnitRonnasteradiansMul;
pub type Yottasteradians<T> = Quantity<T, UnitYottasteradians>;
#[allow(non_upper_case_globals)]
pub static Yottasteradians: UnitYottasteradiansMul = UnitYottasteradiansMul;
pub type Zettasteradians<T> = Quantity<T, UnitZettasteradians>;
#[allow(non_upper_case_globals)]
pub static Zettasteradians: UnitZettasteradiansMul = UnitZettasteradiansMul;
pub type Exasteradians<T> = Quantity<T, UnitExasteradians>;
#[allow(non_upper_case_globals)]
pub static Exasteradians: UnitExasteradiansMul = UnitExasteradiansMul;
pub type Petasteradians<T> = Quantity<T, UnitPetasteradians>;
#[allow(non_upper_case_globals)]
pub static Petasteradians: UnitPetasteradiansMul = UnitPetasteradiansMul;
pub type Terasteradians<T> = Quantity<T, UnitTerasteradians>;
#[allow(non_upper_case_globals)]
pub static Terasteradians: UnitTerasteradiansMul = UnitTerasteradiansMul;
pub type Gigasteradians<T> = Quantity<T, UnitGigasteradians>;
#[allow(non_upper_case_globals)]
pub static Gigasteradians: UnitGigasteradiansMul = UnitGigasteradiansMul;
pub type Megasteradians<T> = Quantity<T, UnitMegasteradians>;
#[allow(non_upper_case_globals)]
pub static Megasteradians: UnitMegasteradiansMul = UnitMegasteradiansMul;
pub type Kilosteradians<T> = Quantity<T, UnitKilosteradians>;
#[allow(non_upper_case_globals)]
pub static Kilosteradians: UnitKilosteradiansMul = UnitKilosteradiansMul;
pub type Hectosteradians<T> = Quantity<T, UnitHectosteradians>;
#[allow(non_upper_case_globals)]
pub static Hectosteradians: UnitHectosteradiansMul = UnitHectosteradiansMul;
pub type Decasteradians<T> = Quantity<T, UnitDecasteradians>;
#[allow(non_upper_case_globals)]
pub static Decasteradians: UnitDecasteradiansMul = UnitDecasteradiansMul;
pub type Decisteradians<T> = Quantity<T, UnitDecisteradians>;
#[allow(non_upper_case_globals)]
pub static Decisteradians: UnitDecisteradiansMul = UnitDecisteradiansMul;
pub type Centisteradians<T> = Quantity<T, UnitCentisteradians>;
#[allow(non_upper_case_globals)]
pub static Centisteradians: UnitCentisteradiansMul = UnitCentisteradiansMul;
pub type Millisteradians<T> = Quantity<T, UnitMillisteradians>;
#[allow(non_upper_case_globals)]
pub static Millisteradians: UnitMillisteradiansMul = UnitMillisteradiansMul;
pub type Microsteradians<T> = Quantity<T, UnitMicrosteradians>;
#[allow(non_upper_case_globals)]
pub static Microsteradians: UnitMicrosteradiansMul = UnitMicrosteradiansMul;
pub type Nanosteradians<T> = Quantity<T, UnitNanosteradians>;
#[allow(non_upper_case_globals)]
pub static Nanosteradians: UnitNanosteradiansMul = UnitNanosteradiansMul;
pub type Picosteradians<T> = Quantity<T, UnitPicosteradians>;
#[allow(non_upper_case_globals)]
pub static Picosteradians: UnitPicosteradiansMul = UnitPicosteradiansMul;
pub type Femtosteradians<T> = Quantity<T, UnitFemtosteradians>;
#[allow(non_upper_case_globals)]
pub static Femtosteradians: UnitFemtosteradiansMul = UnitFemtosteradiansMul;
pub type Attosteradians<T> = Quantity<T, UnitAttosteradians>;
#[allow(non_upper_case_globals)]
pub static Attosteradians: UnitAttosteradiansMul = UnitAttosteradiansMul;
pub type Zeptosteradians<T> = Quantity<T, UnitZeptosteradians>;
#[allow(non_upper_case_globals)]
pub static Zeptosteradians: UnitZeptosteradiansMul = UnitZeptosteradiansMul;
pub type Yoctosteradians<T> = Quantity<T, UnitYoctosteradians>;
#[allow(non_upper_case_globals)]
pub static Yoctosteradians: UnitYoctosteradiansMul = UnitYoctosteradiansMul;
pub type Rontosteradians<T> = Quantity<T, UnitRontosteradians>;
#[allow(non_upper_case_globals)]
pub static Rontosteradians: UnitRontosteradiansMul = UnitRontosteradiansMul;
pub type Quectosteradians<T> = Quantity<T, UnitQuectosteradians>;
#[allow(non_upper_case_globals)]
pub static Quectosteradians: UnitQuectosteradiansMul = UnitQuectosteradiansMul;
pub struct UnitHertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHertz {
    #[inline]
    fn clone(&self) -> UnitHertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHertz {
    #[inline]
    fn eq(&self, other: &UnitHertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHertz {
    fn default() -> Self {
        UnitHertz
    }
}
impl Add<UnitHertz> for UnitHertz {
    type Output = UnitHertz;
    #[inline]
    fn add(self, _: UnitHertz) -> Self::Output {
        UnitHertz
    }
}
impl AddAssign<UnitHertz> for UnitHertz {
    #[inline]
    fn add_assign(&mut self, _: UnitHertz) {}
}
impl Sub<UnitHertz> for UnitHertz {
    type Output = UnitHertz;
    #[inline]
    fn sub(self, _: UnitHertz) -> Self::Output {
        UnitHertz
    }
}
impl SubAssign<UnitHertz> for UnitHertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitHertz) {}
}
pub struct UnitHertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHertzMul {
    #[inline]
    fn clone(&self) -> UnitHertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHertzMul {
    #[inline]
    fn eq(&self, other: &UnitHertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHertzMul> for i8 {
    type Output = Quantity<i8, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for i16 {
    type Output = Quantity<i16, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for i32 {
    type Output = Quantity<i32, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for i64 {
    type Output = Quantity<i64, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for i128 {
    type Output = Quantity<i128, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for isize {
    type Output = Quantity<isize, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for u8 {
    type Output = Quantity<u8, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for u16 {
    type Output = Quantity<u16, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for u32 {
    type Output = Quantity<u32, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for u64 {
    type Output = Quantity<u64, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for u128 {
    type Output = Quantity<u128, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for usize {
    type Output = Quantity<usize, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for f32 {
    type Output = Quantity<f32, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
impl Mul<UnitHertzMul> for f64 {
    type Output = Quantity<f64, UnitHertz>;
    fn mul(self, _: UnitHertzMul) -> Self::Output {
        Quantity::new(self, UnitHertz)
    }
}
pub struct UnitQuettahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahertz {
    #[inline]
    fn clone(&self) -> UnitQuettahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahertz {
    #[inline]
    fn eq(&self, other: &UnitQuettahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettahertz {
    fn default() -> Self {
        UnitQuettahertz
    }
}
impl Add<UnitQuettahertz> for UnitQuettahertz {
    type Output = UnitQuettahertz;
    #[inline]
    fn add(self, _: UnitQuettahertz) -> Self::Output {
        UnitQuettahertz
    }
}
impl AddAssign<UnitQuettahertz> for UnitQuettahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettahertz) {}
}
impl Sub<UnitQuettahertz> for UnitQuettahertz {
    type Output = UnitQuettahertz;
    #[inline]
    fn sub(self, _: UnitQuettahertz) -> Self::Output {
        UnitQuettahertz
    }
}
impl SubAssign<UnitQuettahertz> for UnitQuettahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettahertz) {}
}
pub struct UnitQuettahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahertzMul {
    #[inline]
    fn clone(&self) -> UnitQuettahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahertzMul {
    #[inline]
    fn eq(&self, other: &UnitQuettahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettahertzMul> for i8 {
    type Output = Quantity<i8, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for i16 {
    type Output = Quantity<i16, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for i32 {
    type Output = Quantity<i32, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for i64 {
    type Output = Quantity<i64, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for i128 {
    type Output = Quantity<i128, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for isize {
    type Output = Quantity<isize, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for u8 {
    type Output = Quantity<u8, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for u16 {
    type Output = Quantity<u16, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for u32 {
    type Output = Quantity<u32, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for u64 {
    type Output = Quantity<u64, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for u128 {
    type Output = Quantity<u128, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for usize {
    type Output = Quantity<usize, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for f32 {
    type Output = Quantity<f32, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
impl Mul<UnitQuettahertzMul> for f64 {
    type Output = Quantity<f64, UnitQuettahertz>;
    fn mul(self, _: UnitQuettahertzMul) -> Self::Output {
        Quantity::new(self, UnitQuettahertz)
    }
}
pub struct UnitRonnahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahertz {
    #[inline]
    fn clone(&self) -> UnitRonnahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahertz {
    #[inline]
    fn eq(&self, other: &UnitRonnahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnahertz {
    fn default() -> Self {
        UnitRonnahertz
    }
}
impl Add<UnitRonnahertz> for UnitRonnahertz {
    type Output = UnitRonnahertz;
    #[inline]
    fn add(self, _: UnitRonnahertz) -> Self::Output {
        UnitRonnahertz
    }
}
impl AddAssign<UnitRonnahertz> for UnitRonnahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnahertz) {}
}
impl Sub<UnitRonnahertz> for UnitRonnahertz {
    type Output = UnitRonnahertz;
    #[inline]
    fn sub(self, _: UnitRonnahertz) -> Self::Output {
        UnitRonnahertz
    }
}
impl SubAssign<UnitRonnahertz> for UnitRonnahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnahertz) {}
}
pub struct UnitRonnahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahertzMul {
    #[inline]
    fn clone(&self) -> UnitRonnahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahertzMul {
    #[inline]
    fn eq(&self, other: &UnitRonnahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnahertzMul> for i8 {
    type Output = Quantity<i8, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for i16 {
    type Output = Quantity<i16, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for i32 {
    type Output = Quantity<i32, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for i64 {
    type Output = Quantity<i64, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for i128 {
    type Output = Quantity<i128, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for isize {
    type Output = Quantity<isize, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for u8 {
    type Output = Quantity<u8, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for u16 {
    type Output = Quantity<u16, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for u32 {
    type Output = Quantity<u32, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for u64 {
    type Output = Quantity<u64, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for u128 {
    type Output = Quantity<u128, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for usize {
    type Output = Quantity<usize, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for f32 {
    type Output = Quantity<f32, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
impl Mul<UnitRonnahertzMul> for f64 {
    type Output = Quantity<f64, UnitRonnahertz>;
    fn mul(self, _: UnitRonnahertzMul) -> Self::Output {
        Quantity::new(self, UnitRonnahertz)
    }
}
pub struct UnitYottahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahertz {
    #[inline]
    fn clone(&self) -> UnitYottahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahertz {
    #[inline]
    fn eq(&self, other: &UnitYottahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottahertz {
    fn default() -> Self {
        UnitYottahertz
    }
}
impl Add<UnitYottahertz> for UnitYottahertz {
    type Output = UnitYottahertz;
    #[inline]
    fn add(self, _: UnitYottahertz) -> Self::Output {
        UnitYottahertz
    }
}
impl AddAssign<UnitYottahertz> for UnitYottahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitYottahertz) {}
}
impl Sub<UnitYottahertz> for UnitYottahertz {
    type Output = UnitYottahertz;
    #[inline]
    fn sub(self, _: UnitYottahertz) -> Self::Output {
        UnitYottahertz
    }
}
impl SubAssign<UnitYottahertz> for UnitYottahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottahertz) {}
}
pub struct UnitYottahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahertzMul {
    #[inline]
    fn clone(&self) -> UnitYottahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahertzMul {
    #[inline]
    fn eq(&self, other: &UnitYottahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottahertzMul> for i8 {
    type Output = Quantity<i8, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for i16 {
    type Output = Quantity<i16, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for i32 {
    type Output = Quantity<i32, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for i64 {
    type Output = Quantity<i64, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for i128 {
    type Output = Quantity<i128, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for isize {
    type Output = Quantity<isize, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for u8 {
    type Output = Quantity<u8, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for u16 {
    type Output = Quantity<u16, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for u32 {
    type Output = Quantity<u32, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for u64 {
    type Output = Quantity<u64, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for u128 {
    type Output = Quantity<u128, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for usize {
    type Output = Quantity<usize, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for f32 {
    type Output = Quantity<f32, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
impl Mul<UnitYottahertzMul> for f64 {
    type Output = Quantity<f64, UnitYottahertz>;
    fn mul(self, _: UnitYottahertzMul) -> Self::Output {
        Quantity::new(self, UnitYottahertz)
    }
}
pub struct UnitZettahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahertz {
    #[inline]
    fn clone(&self) -> UnitZettahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahertz {
    #[inline]
    fn eq(&self, other: &UnitZettahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettahertz {
    fn default() -> Self {
        UnitZettahertz
    }
}
impl Add<UnitZettahertz> for UnitZettahertz {
    type Output = UnitZettahertz;
    #[inline]
    fn add(self, _: UnitZettahertz) -> Self::Output {
        UnitZettahertz
    }
}
impl AddAssign<UnitZettahertz> for UnitZettahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitZettahertz) {}
}
impl Sub<UnitZettahertz> for UnitZettahertz {
    type Output = UnitZettahertz;
    #[inline]
    fn sub(self, _: UnitZettahertz) -> Self::Output {
        UnitZettahertz
    }
}
impl SubAssign<UnitZettahertz> for UnitZettahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettahertz) {}
}
pub struct UnitZettahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahertzMul {
    #[inline]
    fn clone(&self) -> UnitZettahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahertzMul {
    #[inline]
    fn eq(&self, other: &UnitZettahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettahertzMul> for i8 {
    type Output = Quantity<i8, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for i16 {
    type Output = Quantity<i16, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for i32 {
    type Output = Quantity<i32, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for i64 {
    type Output = Quantity<i64, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for i128 {
    type Output = Quantity<i128, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for isize {
    type Output = Quantity<isize, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for u8 {
    type Output = Quantity<u8, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for u16 {
    type Output = Quantity<u16, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for u32 {
    type Output = Quantity<u32, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for u64 {
    type Output = Quantity<u64, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for u128 {
    type Output = Quantity<u128, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for usize {
    type Output = Quantity<usize, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for f32 {
    type Output = Quantity<f32, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
impl Mul<UnitZettahertzMul> for f64 {
    type Output = Quantity<f64, UnitZettahertz>;
    fn mul(self, _: UnitZettahertzMul) -> Self::Output {
        Quantity::new(self, UnitZettahertz)
    }
}
pub struct UnitExahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahertz {
    #[inline]
    fn clone(&self) -> UnitExahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahertz {
    #[inline]
    fn eq(&self, other: &UnitExahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExahertz {
    fn default() -> Self {
        UnitExahertz
    }
}
impl Add<UnitExahertz> for UnitExahertz {
    type Output = UnitExahertz;
    #[inline]
    fn add(self, _: UnitExahertz) -> Self::Output {
        UnitExahertz
    }
}
impl AddAssign<UnitExahertz> for UnitExahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitExahertz) {}
}
impl Sub<UnitExahertz> for UnitExahertz {
    type Output = UnitExahertz;
    #[inline]
    fn sub(self, _: UnitExahertz) -> Self::Output {
        UnitExahertz
    }
}
impl SubAssign<UnitExahertz> for UnitExahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitExahertz) {}
}
pub struct UnitExahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahertzMul {
    #[inline]
    fn clone(&self) -> UnitExahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahertzMul {
    #[inline]
    fn eq(&self, other: &UnitExahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExahertzMul> for i8 {
    type Output = Quantity<i8, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for i16 {
    type Output = Quantity<i16, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for i32 {
    type Output = Quantity<i32, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for i64 {
    type Output = Quantity<i64, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for i128 {
    type Output = Quantity<i128, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for isize {
    type Output = Quantity<isize, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for u8 {
    type Output = Quantity<u8, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for u16 {
    type Output = Quantity<u16, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for u32 {
    type Output = Quantity<u32, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for u64 {
    type Output = Quantity<u64, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for u128 {
    type Output = Quantity<u128, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for usize {
    type Output = Quantity<usize, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for f32 {
    type Output = Quantity<f32, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
impl Mul<UnitExahertzMul> for f64 {
    type Output = Quantity<f64, UnitExahertz>;
    fn mul(self, _: UnitExahertzMul) -> Self::Output {
        Quantity::new(self, UnitExahertz)
    }
}
pub struct UnitPetahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahertz {
    #[inline]
    fn clone(&self) -> UnitPetahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahertz {
    #[inline]
    fn eq(&self, other: &UnitPetahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetahertz {
    fn default() -> Self {
        UnitPetahertz
    }
}
impl Add<UnitPetahertz> for UnitPetahertz {
    type Output = UnitPetahertz;
    #[inline]
    fn add(self, _: UnitPetahertz) -> Self::Output {
        UnitPetahertz
    }
}
impl AddAssign<UnitPetahertz> for UnitPetahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitPetahertz) {}
}
impl Sub<UnitPetahertz> for UnitPetahertz {
    type Output = UnitPetahertz;
    #[inline]
    fn sub(self, _: UnitPetahertz) -> Self::Output {
        UnitPetahertz
    }
}
impl SubAssign<UnitPetahertz> for UnitPetahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetahertz) {}
}
pub struct UnitPetahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahertzMul {
    #[inline]
    fn clone(&self) -> UnitPetahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahertzMul {
    #[inline]
    fn eq(&self, other: &UnitPetahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetahertzMul> for i8 {
    type Output = Quantity<i8, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for i16 {
    type Output = Quantity<i16, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for i32 {
    type Output = Quantity<i32, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for i64 {
    type Output = Quantity<i64, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for i128 {
    type Output = Quantity<i128, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for isize {
    type Output = Quantity<isize, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for u8 {
    type Output = Quantity<u8, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for u16 {
    type Output = Quantity<u16, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for u32 {
    type Output = Quantity<u32, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for u64 {
    type Output = Quantity<u64, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for u128 {
    type Output = Quantity<u128, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for usize {
    type Output = Quantity<usize, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for f32 {
    type Output = Quantity<f32, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
impl Mul<UnitPetahertzMul> for f64 {
    type Output = Quantity<f64, UnitPetahertz>;
    fn mul(self, _: UnitPetahertzMul) -> Self::Output {
        Quantity::new(self, UnitPetahertz)
    }
}
pub struct UnitTerahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahertz {
    #[inline]
    fn clone(&self) -> UnitTerahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahertz {
    #[inline]
    fn eq(&self, other: &UnitTerahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerahertz {
    fn default() -> Self {
        UnitTerahertz
    }
}
impl Add<UnitTerahertz> for UnitTerahertz {
    type Output = UnitTerahertz;
    #[inline]
    fn add(self, _: UnitTerahertz) -> Self::Output {
        UnitTerahertz
    }
}
impl AddAssign<UnitTerahertz> for UnitTerahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitTerahertz) {}
}
impl Sub<UnitTerahertz> for UnitTerahertz {
    type Output = UnitTerahertz;
    #[inline]
    fn sub(self, _: UnitTerahertz) -> Self::Output {
        UnitTerahertz
    }
}
impl SubAssign<UnitTerahertz> for UnitTerahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerahertz) {}
}
pub struct UnitTerahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahertzMul {
    #[inline]
    fn clone(&self) -> UnitTerahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahertzMul {
    #[inline]
    fn eq(&self, other: &UnitTerahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerahertzMul> for i8 {
    type Output = Quantity<i8, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for i16 {
    type Output = Quantity<i16, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for i32 {
    type Output = Quantity<i32, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for i64 {
    type Output = Quantity<i64, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for i128 {
    type Output = Quantity<i128, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for isize {
    type Output = Quantity<isize, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for u8 {
    type Output = Quantity<u8, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for u16 {
    type Output = Quantity<u16, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for u32 {
    type Output = Quantity<u32, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for u64 {
    type Output = Quantity<u64, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for u128 {
    type Output = Quantity<u128, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for usize {
    type Output = Quantity<usize, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for f32 {
    type Output = Quantity<f32, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
impl Mul<UnitTerahertzMul> for f64 {
    type Output = Quantity<f64, UnitTerahertz>;
    fn mul(self, _: UnitTerahertzMul) -> Self::Output {
        Quantity::new(self, UnitTerahertz)
    }
}
pub struct UnitGigahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahertz {
    #[inline]
    fn clone(&self) -> UnitGigahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahertz {
    #[inline]
    fn eq(&self, other: &UnitGigahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigahertz {
    fn default() -> Self {
        UnitGigahertz
    }
}
impl Add<UnitGigahertz> for UnitGigahertz {
    type Output = UnitGigahertz;
    #[inline]
    fn add(self, _: UnitGigahertz) -> Self::Output {
        UnitGigahertz
    }
}
impl AddAssign<UnitGigahertz> for UnitGigahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitGigahertz) {}
}
impl Sub<UnitGigahertz> for UnitGigahertz {
    type Output = UnitGigahertz;
    #[inline]
    fn sub(self, _: UnitGigahertz) -> Self::Output {
        UnitGigahertz
    }
}
impl SubAssign<UnitGigahertz> for UnitGigahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigahertz) {}
}
pub struct UnitGigahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahertzMul {
    #[inline]
    fn clone(&self) -> UnitGigahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahertzMul {
    #[inline]
    fn eq(&self, other: &UnitGigahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigahertzMul> for i8 {
    type Output = Quantity<i8, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for i16 {
    type Output = Quantity<i16, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for i32 {
    type Output = Quantity<i32, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for i64 {
    type Output = Quantity<i64, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for i128 {
    type Output = Quantity<i128, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for isize {
    type Output = Quantity<isize, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for u8 {
    type Output = Quantity<u8, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for u16 {
    type Output = Quantity<u16, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for u32 {
    type Output = Quantity<u32, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for u64 {
    type Output = Quantity<u64, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for u128 {
    type Output = Quantity<u128, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for usize {
    type Output = Quantity<usize, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for f32 {
    type Output = Quantity<f32, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
impl Mul<UnitGigahertzMul> for f64 {
    type Output = Quantity<f64, UnitGigahertz>;
    fn mul(self, _: UnitGigahertzMul) -> Self::Output {
        Quantity::new(self, UnitGigahertz)
    }
}
pub struct UnitMegahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahertz {
    #[inline]
    fn clone(&self) -> UnitMegahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahertz {
    #[inline]
    fn eq(&self, other: &UnitMegahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegahertz {
    fn default() -> Self {
        UnitMegahertz
    }
}
impl Add<UnitMegahertz> for UnitMegahertz {
    type Output = UnitMegahertz;
    #[inline]
    fn add(self, _: UnitMegahertz) -> Self::Output {
        UnitMegahertz
    }
}
impl AddAssign<UnitMegahertz> for UnitMegahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitMegahertz) {}
}
impl Sub<UnitMegahertz> for UnitMegahertz {
    type Output = UnitMegahertz;
    #[inline]
    fn sub(self, _: UnitMegahertz) -> Self::Output {
        UnitMegahertz
    }
}
impl SubAssign<UnitMegahertz> for UnitMegahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegahertz) {}
}
pub struct UnitMegahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahertzMul {
    #[inline]
    fn clone(&self) -> UnitMegahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahertzMul {
    #[inline]
    fn eq(&self, other: &UnitMegahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegahertzMul> for i8 {
    type Output = Quantity<i8, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for i16 {
    type Output = Quantity<i16, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for i32 {
    type Output = Quantity<i32, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for i64 {
    type Output = Quantity<i64, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for i128 {
    type Output = Quantity<i128, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for isize {
    type Output = Quantity<isize, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for u8 {
    type Output = Quantity<u8, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for u16 {
    type Output = Quantity<u16, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for u32 {
    type Output = Quantity<u32, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for u64 {
    type Output = Quantity<u64, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for u128 {
    type Output = Quantity<u128, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for usize {
    type Output = Quantity<usize, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for f32 {
    type Output = Quantity<f32, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
impl Mul<UnitMegahertzMul> for f64 {
    type Output = Quantity<f64, UnitMegahertz>;
    fn mul(self, _: UnitMegahertzMul) -> Self::Output {
        Quantity::new(self, UnitMegahertz)
    }
}
pub struct UnitKilohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohertz {
    #[inline]
    fn clone(&self) -> UnitKilohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohertz {
    #[inline]
    fn eq(&self, other: &UnitKilohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilohertz {
    fn default() -> Self {
        UnitKilohertz
    }
}
impl Add<UnitKilohertz> for UnitKilohertz {
    type Output = UnitKilohertz;
    #[inline]
    fn add(self, _: UnitKilohertz) -> Self::Output {
        UnitKilohertz
    }
}
impl AddAssign<UnitKilohertz> for UnitKilohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitKilohertz) {}
}
impl Sub<UnitKilohertz> for UnitKilohertz {
    type Output = UnitKilohertz;
    #[inline]
    fn sub(self, _: UnitKilohertz) -> Self::Output {
        UnitKilohertz
    }
}
impl SubAssign<UnitKilohertz> for UnitKilohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilohertz) {}
}
pub struct UnitKilohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohertzMul {
    #[inline]
    fn clone(&self) -> UnitKilohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohertzMul {
    #[inline]
    fn eq(&self, other: &UnitKilohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilohertzMul> for i8 {
    type Output = Quantity<i8, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for i16 {
    type Output = Quantity<i16, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for i32 {
    type Output = Quantity<i32, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for i64 {
    type Output = Quantity<i64, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for i128 {
    type Output = Quantity<i128, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for isize {
    type Output = Quantity<isize, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for u8 {
    type Output = Quantity<u8, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for u16 {
    type Output = Quantity<u16, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for u32 {
    type Output = Quantity<u32, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for u64 {
    type Output = Quantity<u64, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for u128 {
    type Output = Quantity<u128, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for usize {
    type Output = Quantity<usize, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for f32 {
    type Output = Quantity<f32, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
impl Mul<UnitKilohertzMul> for f64 {
    type Output = Quantity<f64, UnitKilohertz>;
    fn mul(self, _: UnitKilohertzMul) -> Self::Output {
        Quantity::new(self, UnitKilohertz)
    }
}
pub struct UnitHectohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohertz {
    #[inline]
    fn clone(&self) -> UnitHectohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohertz {
    #[inline]
    fn eq(&self, other: &UnitHectohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectohertz {
    fn default() -> Self {
        UnitHectohertz
    }
}
impl Add<UnitHectohertz> for UnitHectohertz {
    type Output = UnitHectohertz;
    #[inline]
    fn add(self, _: UnitHectohertz) -> Self::Output {
        UnitHectohertz
    }
}
impl AddAssign<UnitHectohertz> for UnitHectohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitHectohertz) {}
}
impl Sub<UnitHectohertz> for UnitHectohertz {
    type Output = UnitHectohertz;
    #[inline]
    fn sub(self, _: UnitHectohertz) -> Self::Output {
        UnitHectohertz
    }
}
impl SubAssign<UnitHectohertz> for UnitHectohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectohertz) {}
}
pub struct UnitHectohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohertzMul {
    #[inline]
    fn clone(&self) -> UnitHectohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohertzMul {
    #[inline]
    fn eq(&self, other: &UnitHectohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectohertzMul> for i8 {
    type Output = Quantity<i8, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for i16 {
    type Output = Quantity<i16, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for i32 {
    type Output = Quantity<i32, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for i64 {
    type Output = Quantity<i64, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for i128 {
    type Output = Quantity<i128, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for isize {
    type Output = Quantity<isize, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for u8 {
    type Output = Quantity<u8, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for u16 {
    type Output = Quantity<u16, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for u32 {
    type Output = Quantity<u32, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for u64 {
    type Output = Quantity<u64, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for u128 {
    type Output = Quantity<u128, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for usize {
    type Output = Quantity<usize, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for f32 {
    type Output = Quantity<f32, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
impl Mul<UnitHectohertzMul> for f64 {
    type Output = Quantity<f64, UnitHectohertz>;
    fn mul(self, _: UnitHectohertzMul) -> Self::Output {
        Quantity::new(self, UnitHectohertz)
    }
}
pub struct UnitDecahertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahertz {
    #[inline]
    fn clone(&self) -> UnitDecahertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahertz {
    #[inline]
    fn eq(&self, other: &UnitDecahertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecahertz {
    fn default() -> Self {
        UnitDecahertz
    }
}
impl Add<UnitDecahertz> for UnitDecahertz {
    type Output = UnitDecahertz;
    #[inline]
    fn add(self, _: UnitDecahertz) -> Self::Output {
        UnitDecahertz
    }
}
impl AddAssign<UnitDecahertz> for UnitDecahertz {
    #[inline]
    fn add_assign(&mut self, _: UnitDecahertz) {}
}
impl Sub<UnitDecahertz> for UnitDecahertz {
    type Output = UnitDecahertz;
    #[inline]
    fn sub(self, _: UnitDecahertz) -> Self::Output {
        UnitDecahertz
    }
}
impl SubAssign<UnitDecahertz> for UnitDecahertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecahertz) {}
}
pub struct UnitDecahertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahertzMul {
    #[inline]
    fn clone(&self) -> UnitDecahertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahertzMul {
    #[inline]
    fn eq(&self, other: &UnitDecahertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecahertzMul> for i8 {
    type Output = Quantity<i8, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for i16 {
    type Output = Quantity<i16, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for i32 {
    type Output = Quantity<i32, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for i64 {
    type Output = Quantity<i64, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for i128 {
    type Output = Quantity<i128, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for isize {
    type Output = Quantity<isize, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for u8 {
    type Output = Quantity<u8, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for u16 {
    type Output = Quantity<u16, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for u32 {
    type Output = Quantity<u32, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for u64 {
    type Output = Quantity<u64, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for u128 {
    type Output = Quantity<u128, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for usize {
    type Output = Quantity<usize, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for f32 {
    type Output = Quantity<f32, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
impl Mul<UnitDecahertzMul> for f64 {
    type Output = Quantity<f64, UnitDecahertz>;
    fn mul(self, _: UnitDecahertzMul) -> Self::Output {
        Quantity::new(self, UnitDecahertz)
    }
}
pub struct UnitDecihertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihertz {
    #[inline]
    fn clone(&self) -> UnitDecihertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihertz {
    #[inline]
    fn eq(&self, other: &UnitDecihertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecihertz {
    fn default() -> Self {
        UnitDecihertz
    }
}
impl Add<UnitDecihertz> for UnitDecihertz {
    type Output = UnitDecihertz;
    #[inline]
    fn add(self, _: UnitDecihertz) -> Self::Output {
        UnitDecihertz
    }
}
impl AddAssign<UnitDecihertz> for UnitDecihertz {
    #[inline]
    fn add_assign(&mut self, _: UnitDecihertz) {}
}
impl Sub<UnitDecihertz> for UnitDecihertz {
    type Output = UnitDecihertz;
    #[inline]
    fn sub(self, _: UnitDecihertz) -> Self::Output {
        UnitDecihertz
    }
}
impl SubAssign<UnitDecihertz> for UnitDecihertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecihertz) {}
}
pub struct UnitDecihertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihertzMul {
    #[inline]
    fn clone(&self) -> UnitDecihertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihertzMul {
    #[inline]
    fn eq(&self, other: &UnitDecihertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecihertzMul> for i8 {
    type Output = Quantity<i8, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for i16 {
    type Output = Quantity<i16, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for i32 {
    type Output = Quantity<i32, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for i64 {
    type Output = Quantity<i64, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for i128 {
    type Output = Quantity<i128, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for isize {
    type Output = Quantity<isize, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for u8 {
    type Output = Quantity<u8, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for u16 {
    type Output = Quantity<u16, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for u32 {
    type Output = Quantity<u32, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for u64 {
    type Output = Quantity<u64, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for u128 {
    type Output = Quantity<u128, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for usize {
    type Output = Quantity<usize, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for f32 {
    type Output = Quantity<f32, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
impl Mul<UnitDecihertzMul> for f64 {
    type Output = Quantity<f64, UnitDecihertz>;
    fn mul(self, _: UnitDecihertzMul) -> Self::Output {
        Quantity::new(self, UnitDecihertz)
    }
}
pub struct UnitCentihertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihertz {
    #[inline]
    fn clone(&self) -> UnitCentihertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihertz {
    #[inline]
    fn eq(&self, other: &UnitCentihertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentihertz {
    fn default() -> Self {
        UnitCentihertz
    }
}
impl Add<UnitCentihertz> for UnitCentihertz {
    type Output = UnitCentihertz;
    #[inline]
    fn add(self, _: UnitCentihertz) -> Self::Output {
        UnitCentihertz
    }
}
impl AddAssign<UnitCentihertz> for UnitCentihertz {
    #[inline]
    fn add_assign(&mut self, _: UnitCentihertz) {}
}
impl Sub<UnitCentihertz> for UnitCentihertz {
    type Output = UnitCentihertz;
    #[inline]
    fn sub(self, _: UnitCentihertz) -> Self::Output {
        UnitCentihertz
    }
}
impl SubAssign<UnitCentihertz> for UnitCentihertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentihertz) {}
}
pub struct UnitCentihertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihertzMul {
    #[inline]
    fn clone(&self) -> UnitCentihertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihertzMul {
    #[inline]
    fn eq(&self, other: &UnitCentihertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentihertzMul> for i8 {
    type Output = Quantity<i8, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for i16 {
    type Output = Quantity<i16, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for i32 {
    type Output = Quantity<i32, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for i64 {
    type Output = Quantity<i64, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for i128 {
    type Output = Quantity<i128, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for isize {
    type Output = Quantity<isize, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for u8 {
    type Output = Quantity<u8, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for u16 {
    type Output = Quantity<u16, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for u32 {
    type Output = Quantity<u32, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for u64 {
    type Output = Quantity<u64, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for u128 {
    type Output = Quantity<u128, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for usize {
    type Output = Quantity<usize, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for f32 {
    type Output = Quantity<f32, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
impl Mul<UnitCentihertzMul> for f64 {
    type Output = Quantity<f64, UnitCentihertz>;
    fn mul(self, _: UnitCentihertzMul) -> Self::Output {
        Quantity::new(self, UnitCentihertz)
    }
}
pub struct UnitMillihertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihertz {
    #[inline]
    fn clone(&self) -> UnitMillihertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihertz {
    #[inline]
    fn eq(&self, other: &UnitMillihertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillihertz {
    fn default() -> Self {
        UnitMillihertz
    }
}
impl Add<UnitMillihertz> for UnitMillihertz {
    type Output = UnitMillihertz;
    #[inline]
    fn add(self, _: UnitMillihertz) -> Self::Output {
        UnitMillihertz
    }
}
impl AddAssign<UnitMillihertz> for UnitMillihertz {
    #[inline]
    fn add_assign(&mut self, _: UnitMillihertz) {}
}
impl Sub<UnitMillihertz> for UnitMillihertz {
    type Output = UnitMillihertz;
    #[inline]
    fn sub(self, _: UnitMillihertz) -> Self::Output {
        UnitMillihertz
    }
}
impl SubAssign<UnitMillihertz> for UnitMillihertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillihertz) {}
}
pub struct UnitMillihertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihertzMul {
    #[inline]
    fn clone(&self) -> UnitMillihertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihertzMul {
    #[inline]
    fn eq(&self, other: &UnitMillihertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillihertzMul> for i8 {
    type Output = Quantity<i8, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for i16 {
    type Output = Quantity<i16, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for i32 {
    type Output = Quantity<i32, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for i64 {
    type Output = Quantity<i64, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for i128 {
    type Output = Quantity<i128, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for isize {
    type Output = Quantity<isize, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for u8 {
    type Output = Quantity<u8, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for u16 {
    type Output = Quantity<u16, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for u32 {
    type Output = Quantity<u32, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for u64 {
    type Output = Quantity<u64, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for u128 {
    type Output = Quantity<u128, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for usize {
    type Output = Quantity<usize, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for f32 {
    type Output = Quantity<f32, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
impl Mul<UnitMillihertzMul> for f64 {
    type Output = Quantity<f64, UnitMillihertz>;
    fn mul(self, _: UnitMillihertzMul) -> Self::Output {
        Quantity::new(self, UnitMillihertz)
    }
}
pub struct UnitMicrohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohertz {
    #[inline]
    fn clone(&self) -> UnitMicrohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohertz {
    #[inline]
    fn eq(&self, other: &UnitMicrohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrohertz {
    fn default() -> Self {
        UnitMicrohertz
    }
}
impl Add<UnitMicrohertz> for UnitMicrohertz {
    type Output = UnitMicrohertz;
    #[inline]
    fn add(self, _: UnitMicrohertz) -> Self::Output {
        UnitMicrohertz
    }
}
impl AddAssign<UnitMicrohertz> for UnitMicrohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrohertz) {}
}
impl Sub<UnitMicrohertz> for UnitMicrohertz {
    type Output = UnitMicrohertz;
    #[inline]
    fn sub(self, _: UnitMicrohertz) -> Self::Output {
        UnitMicrohertz
    }
}
impl SubAssign<UnitMicrohertz> for UnitMicrohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrohertz) {}
}
pub struct UnitMicrohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohertzMul {
    #[inline]
    fn clone(&self) -> UnitMicrohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohertzMul {
    #[inline]
    fn eq(&self, other: &UnitMicrohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrohertzMul> for i8 {
    type Output = Quantity<i8, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for i16 {
    type Output = Quantity<i16, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for i32 {
    type Output = Quantity<i32, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for i64 {
    type Output = Quantity<i64, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for i128 {
    type Output = Quantity<i128, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for isize {
    type Output = Quantity<isize, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for u8 {
    type Output = Quantity<u8, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for u16 {
    type Output = Quantity<u16, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for u32 {
    type Output = Quantity<u32, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for u64 {
    type Output = Quantity<u64, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for u128 {
    type Output = Quantity<u128, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for usize {
    type Output = Quantity<usize, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for f32 {
    type Output = Quantity<f32, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
impl Mul<UnitMicrohertzMul> for f64 {
    type Output = Quantity<f64, UnitMicrohertz>;
    fn mul(self, _: UnitMicrohertzMul) -> Self::Output {
        Quantity::new(self, UnitMicrohertz)
    }
}
pub struct UnitNanohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohertz {
    #[inline]
    fn clone(&self) -> UnitNanohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohertz {
    #[inline]
    fn eq(&self, other: &UnitNanohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanohertz {
    fn default() -> Self {
        UnitNanohertz
    }
}
impl Add<UnitNanohertz> for UnitNanohertz {
    type Output = UnitNanohertz;
    #[inline]
    fn add(self, _: UnitNanohertz) -> Self::Output {
        UnitNanohertz
    }
}
impl AddAssign<UnitNanohertz> for UnitNanohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitNanohertz) {}
}
impl Sub<UnitNanohertz> for UnitNanohertz {
    type Output = UnitNanohertz;
    #[inline]
    fn sub(self, _: UnitNanohertz) -> Self::Output {
        UnitNanohertz
    }
}
impl SubAssign<UnitNanohertz> for UnitNanohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanohertz) {}
}
pub struct UnitNanohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohertzMul {
    #[inline]
    fn clone(&self) -> UnitNanohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohertzMul {
    #[inline]
    fn eq(&self, other: &UnitNanohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanohertzMul> for i8 {
    type Output = Quantity<i8, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for i16 {
    type Output = Quantity<i16, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for i32 {
    type Output = Quantity<i32, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for i64 {
    type Output = Quantity<i64, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for i128 {
    type Output = Quantity<i128, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for isize {
    type Output = Quantity<isize, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for u8 {
    type Output = Quantity<u8, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for u16 {
    type Output = Quantity<u16, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for u32 {
    type Output = Quantity<u32, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for u64 {
    type Output = Quantity<u64, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for u128 {
    type Output = Quantity<u128, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for usize {
    type Output = Quantity<usize, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for f32 {
    type Output = Quantity<f32, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
impl Mul<UnitNanohertzMul> for f64 {
    type Output = Quantity<f64, UnitNanohertz>;
    fn mul(self, _: UnitNanohertzMul) -> Self::Output {
        Quantity::new(self, UnitNanohertz)
    }
}
pub struct UnitPicohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohertz {
    #[inline]
    fn clone(&self) -> UnitPicohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohertz {
    #[inline]
    fn eq(&self, other: &UnitPicohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicohertz {
    fn default() -> Self {
        UnitPicohertz
    }
}
impl Add<UnitPicohertz> for UnitPicohertz {
    type Output = UnitPicohertz;
    #[inline]
    fn add(self, _: UnitPicohertz) -> Self::Output {
        UnitPicohertz
    }
}
impl AddAssign<UnitPicohertz> for UnitPicohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitPicohertz) {}
}
impl Sub<UnitPicohertz> for UnitPicohertz {
    type Output = UnitPicohertz;
    #[inline]
    fn sub(self, _: UnitPicohertz) -> Self::Output {
        UnitPicohertz
    }
}
impl SubAssign<UnitPicohertz> for UnitPicohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicohertz) {}
}
pub struct UnitPicohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohertzMul {
    #[inline]
    fn clone(&self) -> UnitPicohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohertzMul {
    #[inline]
    fn eq(&self, other: &UnitPicohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicohertzMul> for i8 {
    type Output = Quantity<i8, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for i16 {
    type Output = Quantity<i16, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for i32 {
    type Output = Quantity<i32, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for i64 {
    type Output = Quantity<i64, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for i128 {
    type Output = Quantity<i128, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for isize {
    type Output = Quantity<isize, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for u8 {
    type Output = Quantity<u8, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for u16 {
    type Output = Quantity<u16, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for u32 {
    type Output = Quantity<u32, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for u64 {
    type Output = Quantity<u64, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for u128 {
    type Output = Quantity<u128, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for usize {
    type Output = Quantity<usize, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for f32 {
    type Output = Quantity<f32, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
impl Mul<UnitPicohertzMul> for f64 {
    type Output = Quantity<f64, UnitPicohertz>;
    fn mul(self, _: UnitPicohertzMul) -> Self::Output {
        Quantity::new(self, UnitPicohertz)
    }
}
pub struct UnitFemtohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohertz {
    #[inline]
    fn clone(&self) -> UnitFemtohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohertz {
    #[inline]
    fn eq(&self, other: &UnitFemtohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtohertz {
    fn default() -> Self {
        UnitFemtohertz
    }
}
impl Add<UnitFemtohertz> for UnitFemtohertz {
    type Output = UnitFemtohertz;
    #[inline]
    fn add(self, _: UnitFemtohertz) -> Self::Output {
        UnitFemtohertz
    }
}
impl AddAssign<UnitFemtohertz> for UnitFemtohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtohertz) {}
}
impl Sub<UnitFemtohertz> for UnitFemtohertz {
    type Output = UnitFemtohertz;
    #[inline]
    fn sub(self, _: UnitFemtohertz) -> Self::Output {
        UnitFemtohertz
    }
}
impl SubAssign<UnitFemtohertz> for UnitFemtohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtohertz) {}
}
pub struct UnitFemtohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohertzMul {
    #[inline]
    fn clone(&self) -> UnitFemtohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohertzMul {
    #[inline]
    fn eq(&self, other: &UnitFemtohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtohertzMul> for i8 {
    type Output = Quantity<i8, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for i16 {
    type Output = Quantity<i16, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for i32 {
    type Output = Quantity<i32, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for i64 {
    type Output = Quantity<i64, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for i128 {
    type Output = Quantity<i128, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for isize {
    type Output = Quantity<isize, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for u8 {
    type Output = Quantity<u8, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for u16 {
    type Output = Quantity<u16, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for u32 {
    type Output = Quantity<u32, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for u64 {
    type Output = Quantity<u64, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for u128 {
    type Output = Quantity<u128, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for usize {
    type Output = Quantity<usize, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for f32 {
    type Output = Quantity<f32, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
impl Mul<UnitFemtohertzMul> for f64 {
    type Output = Quantity<f64, UnitFemtohertz>;
    fn mul(self, _: UnitFemtohertzMul) -> Self::Output {
        Quantity::new(self, UnitFemtohertz)
    }
}
pub struct UnitAttohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohertz {
    #[inline]
    fn clone(&self) -> UnitAttohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohertz {
    #[inline]
    fn eq(&self, other: &UnitAttohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttohertz {
    fn default() -> Self {
        UnitAttohertz
    }
}
impl Add<UnitAttohertz> for UnitAttohertz {
    type Output = UnitAttohertz;
    #[inline]
    fn add(self, _: UnitAttohertz) -> Self::Output {
        UnitAttohertz
    }
}
impl AddAssign<UnitAttohertz> for UnitAttohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitAttohertz) {}
}
impl Sub<UnitAttohertz> for UnitAttohertz {
    type Output = UnitAttohertz;
    #[inline]
    fn sub(self, _: UnitAttohertz) -> Self::Output {
        UnitAttohertz
    }
}
impl SubAssign<UnitAttohertz> for UnitAttohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttohertz) {}
}
pub struct UnitAttohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohertzMul {
    #[inline]
    fn clone(&self) -> UnitAttohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohertzMul {
    #[inline]
    fn eq(&self, other: &UnitAttohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttohertzMul> for i8 {
    type Output = Quantity<i8, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for i16 {
    type Output = Quantity<i16, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for i32 {
    type Output = Quantity<i32, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for i64 {
    type Output = Quantity<i64, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for i128 {
    type Output = Quantity<i128, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for isize {
    type Output = Quantity<isize, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for u8 {
    type Output = Quantity<u8, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for u16 {
    type Output = Quantity<u16, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for u32 {
    type Output = Quantity<u32, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for u64 {
    type Output = Quantity<u64, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for u128 {
    type Output = Quantity<u128, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for usize {
    type Output = Quantity<usize, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for f32 {
    type Output = Quantity<f32, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
impl Mul<UnitAttohertzMul> for f64 {
    type Output = Quantity<f64, UnitAttohertz>;
    fn mul(self, _: UnitAttohertzMul) -> Self::Output {
        Quantity::new(self, UnitAttohertz)
    }
}
pub struct UnitZeptohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohertz {
    #[inline]
    fn clone(&self) -> UnitZeptohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohertz {
    #[inline]
    fn eq(&self, other: &UnitZeptohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptohertz {
    fn default() -> Self {
        UnitZeptohertz
    }
}
impl Add<UnitZeptohertz> for UnitZeptohertz {
    type Output = UnitZeptohertz;
    #[inline]
    fn add(self, _: UnitZeptohertz) -> Self::Output {
        UnitZeptohertz
    }
}
impl AddAssign<UnitZeptohertz> for UnitZeptohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptohertz) {}
}
impl Sub<UnitZeptohertz> for UnitZeptohertz {
    type Output = UnitZeptohertz;
    #[inline]
    fn sub(self, _: UnitZeptohertz) -> Self::Output {
        UnitZeptohertz
    }
}
impl SubAssign<UnitZeptohertz> for UnitZeptohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptohertz) {}
}
pub struct UnitZeptohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohertzMul {
    #[inline]
    fn clone(&self) -> UnitZeptohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohertzMul {
    #[inline]
    fn eq(&self, other: &UnitZeptohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptohertzMul> for i8 {
    type Output = Quantity<i8, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for i16 {
    type Output = Quantity<i16, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for i32 {
    type Output = Quantity<i32, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for i64 {
    type Output = Quantity<i64, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for i128 {
    type Output = Quantity<i128, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for isize {
    type Output = Quantity<isize, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for u8 {
    type Output = Quantity<u8, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for u16 {
    type Output = Quantity<u16, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for u32 {
    type Output = Quantity<u32, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for u64 {
    type Output = Quantity<u64, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for u128 {
    type Output = Quantity<u128, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for usize {
    type Output = Quantity<usize, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for f32 {
    type Output = Quantity<f32, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
impl Mul<UnitZeptohertzMul> for f64 {
    type Output = Quantity<f64, UnitZeptohertz>;
    fn mul(self, _: UnitZeptohertzMul) -> Self::Output {
        Quantity::new(self, UnitZeptohertz)
    }
}
pub struct UnitYoctohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohertz {
    #[inline]
    fn clone(&self) -> UnitYoctohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohertz {
    #[inline]
    fn eq(&self, other: &UnitYoctohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctohertz {
    fn default() -> Self {
        UnitYoctohertz
    }
}
impl Add<UnitYoctohertz> for UnitYoctohertz {
    type Output = UnitYoctohertz;
    #[inline]
    fn add(self, _: UnitYoctohertz) -> Self::Output {
        UnitYoctohertz
    }
}
impl AddAssign<UnitYoctohertz> for UnitYoctohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctohertz) {}
}
impl Sub<UnitYoctohertz> for UnitYoctohertz {
    type Output = UnitYoctohertz;
    #[inline]
    fn sub(self, _: UnitYoctohertz) -> Self::Output {
        UnitYoctohertz
    }
}
impl SubAssign<UnitYoctohertz> for UnitYoctohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctohertz) {}
}
pub struct UnitYoctohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohertzMul {
    #[inline]
    fn clone(&self) -> UnitYoctohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohertzMul {
    #[inline]
    fn eq(&self, other: &UnitYoctohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctohertzMul> for i8 {
    type Output = Quantity<i8, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for i16 {
    type Output = Quantity<i16, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for i32 {
    type Output = Quantity<i32, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for i64 {
    type Output = Quantity<i64, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for i128 {
    type Output = Quantity<i128, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for isize {
    type Output = Quantity<isize, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for u8 {
    type Output = Quantity<u8, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for u16 {
    type Output = Quantity<u16, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for u32 {
    type Output = Quantity<u32, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for u64 {
    type Output = Quantity<u64, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for u128 {
    type Output = Quantity<u128, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for usize {
    type Output = Quantity<usize, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for f32 {
    type Output = Quantity<f32, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
impl Mul<UnitYoctohertzMul> for f64 {
    type Output = Quantity<f64, UnitYoctohertz>;
    fn mul(self, _: UnitYoctohertzMul) -> Self::Output {
        Quantity::new(self, UnitYoctohertz)
    }
}
pub struct UnitRontohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohertz {
    #[inline]
    fn clone(&self) -> UnitRontohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohertz {
    #[inline]
    fn eq(&self, other: &UnitRontohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontohertz {
    fn default() -> Self {
        UnitRontohertz
    }
}
impl Add<UnitRontohertz> for UnitRontohertz {
    type Output = UnitRontohertz;
    #[inline]
    fn add(self, _: UnitRontohertz) -> Self::Output {
        UnitRontohertz
    }
}
impl AddAssign<UnitRontohertz> for UnitRontohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitRontohertz) {}
}
impl Sub<UnitRontohertz> for UnitRontohertz {
    type Output = UnitRontohertz;
    #[inline]
    fn sub(self, _: UnitRontohertz) -> Self::Output {
        UnitRontohertz
    }
}
impl SubAssign<UnitRontohertz> for UnitRontohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontohertz) {}
}
pub struct UnitRontohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohertzMul {
    #[inline]
    fn clone(&self) -> UnitRontohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohertzMul {
    #[inline]
    fn eq(&self, other: &UnitRontohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontohertzMul> for i8 {
    type Output = Quantity<i8, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for i16 {
    type Output = Quantity<i16, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for i32 {
    type Output = Quantity<i32, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for i64 {
    type Output = Quantity<i64, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for i128 {
    type Output = Quantity<i128, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for isize {
    type Output = Quantity<isize, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for u8 {
    type Output = Quantity<u8, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for u16 {
    type Output = Quantity<u16, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for u32 {
    type Output = Quantity<u32, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for u64 {
    type Output = Quantity<u64, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for u128 {
    type Output = Quantity<u128, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for usize {
    type Output = Quantity<usize, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for f32 {
    type Output = Quantity<f32, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
impl Mul<UnitRontohertzMul> for f64 {
    type Output = Quantity<f64, UnitRontohertz>;
    fn mul(self, _: UnitRontohertzMul) -> Self::Output {
        Quantity::new(self, UnitRontohertz)
    }
}
pub struct UnitQuectohertz;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohertz {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohertz")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohertz {
    #[inline]
    fn clone(&self) -> UnitQuectohertz {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohertz {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohertz {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohertz {
    #[inline]
    fn eq(&self, other: &UnitQuectohertz) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohertz {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectohertz {
    fn default() -> Self {
        UnitQuectohertz
    }
}
impl Add<UnitQuectohertz> for UnitQuectohertz {
    type Output = UnitQuectohertz;
    #[inline]
    fn add(self, _: UnitQuectohertz) -> Self::Output {
        UnitQuectohertz
    }
}
impl AddAssign<UnitQuectohertz> for UnitQuectohertz {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectohertz) {}
}
impl Sub<UnitQuectohertz> for UnitQuectohertz {
    type Output = UnitQuectohertz;
    #[inline]
    fn sub(self, _: UnitQuectohertz) -> Self::Output {
        UnitQuectohertz
    }
}
impl SubAssign<UnitQuectohertz> for UnitQuectohertz {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectohertz) {}
}
pub struct UnitQuectohertzMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohertzMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohertzMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohertzMul {
    #[inline]
    fn clone(&self) -> UnitQuectohertzMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohertzMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohertzMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohertzMul {
    #[inline]
    fn eq(&self, other: &UnitQuectohertzMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohertzMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectohertzMul> for i8 {
    type Output = Quantity<i8, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for i16 {
    type Output = Quantity<i16, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for i32 {
    type Output = Quantity<i32, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for i64 {
    type Output = Quantity<i64, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for i128 {
    type Output = Quantity<i128, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for isize {
    type Output = Quantity<isize, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for u8 {
    type Output = Quantity<u8, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for u16 {
    type Output = Quantity<u16, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for u32 {
    type Output = Quantity<u32, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for u64 {
    type Output = Quantity<u64, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for u128 {
    type Output = Quantity<u128, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for usize {
    type Output = Quantity<usize, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for f32 {
    type Output = Quantity<f32, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
impl Mul<UnitQuectohertzMul> for f64 {
    type Output = Quantity<f64, UnitQuectohertz>;
    fn mul(self, _: UnitQuectohertzMul) -> Self::Output {
        Quantity::new(self, UnitQuectohertz)
    }
}
pub type Hertz<T> = Quantity<T, UnitHertz>;
#[allow(non_upper_case_globals)]
pub static Hertz: UnitHertzMul = UnitHertzMul;
pub type Quettahertz<T> = Quantity<T, UnitQuettahertz>;
#[allow(non_upper_case_globals)]
pub static Quettahertz: UnitQuettahertzMul = UnitQuettahertzMul;
pub type Ronnahertz<T> = Quantity<T, UnitRonnahertz>;
#[allow(non_upper_case_globals)]
pub static Ronnahertz: UnitRonnahertzMul = UnitRonnahertzMul;
pub type Yottahertz<T> = Quantity<T, UnitYottahertz>;
#[allow(non_upper_case_globals)]
pub static Yottahertz: UnitYottahertzMul = UnitYottahertzMul;
pub type Zettahertz<T> = Quantity<T, UnitZettahertz>;
#[allow(non_upper_case_globals)]
pub static Zettahertz: UnitZettahertzMul = UnitZettahertzMul;
pub type Exahertz<T> = Quantity<T, UnitExahertz>;
#[allow(non_upper_case_globals)]
pub static Exahertz: UnitExahertzMul = UnitExahertzMul;
pub type Petahertz<T> = Quantity<T, UnitPetahertz>;
#[allow(non_upper_case_globals)]
pub static Petahertz: UnitPetahertzMul = UnitPetahertzMul;
pub type Terahertz<T> = Quantity<T, UnitTerahertz>;
#[allow(non_upper_case_globals)]
pub static Terahertz: UnitTerahertzMul = UnitTerahertzMul;
pub type Gigahertz<T> = Quantity<T, UnitGigahertz>;
#[allow(non_upper_case_globals)]
pub static Gigahertz: UnitGigahertzMul = UnitGigahertzMul;
pub type Megahertz<T> = Quantity<T, UnitMegahertz>;
#[allow(non_upper_case_globals)]
pub static Megahertz: UnitMegahertzMul = UnitMegahertzMul;
pub type Kilohertz<T> = Quantity<T, UnitKilohertz>;
#[allow(non_upper_case_globals)]
pub static Kilohertz: UnitKilohertzMul = UnitKilohertzMul;
pub type Hectohertz<T> = Quantity<T, UnitHectohertz>;
#[allow(non_upper_case_globals)]
pub static Hectohertz: UnitHectohertzMul = UnitHectohertzMul;
pub type Decahertz<T> = Quantity<T, UnitDecahertz>;
#[allow(non_upper_case_globals)]
pub static Decahertz: UnitDecahertzMul = UnitDecahertzMul;
pub type Decihertz<T> = Quantity<T, UnitDecihertz>;
#[allow(non_upper_case_globals)]
pub static Decihertz: UnitDecihertzMul = UnitDecihertzMul;
pub type Centihertz<T> = Quantity<T, UnitCentihertz>;
#[allow(non_upper_case_globals)]
pub static Centihertz: UnitCentihertzMul = UnitCentihertzMul;
pub type Millihertz<T> = Quantity<T, UnitMillihertz>;
#[allow(non_upper_case_globals)]
pub static Millihertz: UnitMillihertzMul = UnitMillihertzMul;
pub type Microhertz<T> = Quantity<T, UnitMicrohertz>;
#[allow(non_upper_case_globals)]
pub static Microhertz: UnitMicrohertzMul = UnitMicrohertzMul;
pub type Nanohertz<T> = Quantity<T, UnitNanohertz>;
#[allow(non_upper_case_globals)]
pub static Nanohertz: UnitNanohertzMul = UnitNanohertzMul;
pub type Picohertz<T> = Quantity<T, UnitPicohertz>;
#[allow(non_upper_case_globals)]
pub static Picohertz: UnitPicohertzMul = UnitPicohertzMul;
pub type Femtohertz<T> = Quantity<T, UnitFemtohertz>;
#[allow(non_upper_case_globals)]
pub static Femtohertz: UnitFemtohertzMul = UnitFemtohertzMul;
pub type Attohertz<T> = Quantity<T, UnitAttohertz>;
#[allow(non_upper_case_globals)]
pub static Attohertz: UnitAttohertzMul = UnitAttohertzMul;
pub type Zeptohertz<T> = Quantity<T, UnitZeptohertz>;
#[allow(non_upper_case_globals)]
pub static Zeptohertz: UnitZeptohertzMul = UnitZeptohertzMul;
pub type Yoctohertz<T> = Quantity<T, UnitYoctohertz>;
#[allow(non_upper_case_globals)]
pub static Yoctohertz: UnitYoctohertzMul = UnitYoctohertzMul;
pub type Rontohertz<T> = Quantity<T, UnitRontohertz>;
#[allow(non_upper_case_globals)]
pub static Rontohertz: UnitRontohertzMul = UnitRontohertzMul;
pub type Quectohertz<T> = Quantity<T, UnitQuectohertz>;
#[allow(non_upper_case_globals)]
pub static Quectohertz: UnitQuectohertzMul = UnitQuectohertzMul;
pub struct UnitNewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNewtons {
    #[inline]
    fn clone(&self) -> UnitNewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNewtons {
    #[inline]
    fn eq(&self, other: &UnitNewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNewtons {
    fn default() -> Self {
        UnitNewtons
    }
}
impl Add<UnitNewtons> for UnitNewtons {
    type Output = UnitNewtons;
    #[inline]
    fn add(self, _: UnitNewtons) -> Self::Output {
        UnitNewtons
    }
}
impl AddAssign<UnitNewtons> for UnitNewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitNewtons) {}
}
impl Sub<UnitNewtons> for UnitNewtons {
    type Output = UnitNewtons;
    #[inline]
    fn sub(self, _: UnitNewtons) -> Self::Output {
        UnitNewtons
    }
}
impl SubAssign<UnitNewtons> for UnitNewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitNewtons) {}
}
pub struct UnitNewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNewtonsMul {
    #[inline]
    fn clone(&self) -> UnitNewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitNewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNewtonsMul> for i8 {
    type Output = Quantity<i8, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for i16 {
    type Output = Quantity<i16, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for i32 {
    type Output = Quantity<i32, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for i64 {
    type Output = Quantity<i64, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for i128 {
    type Output = Quantity<i128, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for isize {
    type Output = Quantity<isize, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for u8 {
    type Output = Quantity<u8, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for u16 {
    type Output = Quantity<u16, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for u32 {
    type Output = Quantity<u32, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for u64 {
    type Output = Quantity<u64, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for u128 {
    type Output = Quantity<u128, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for usize {
    type Output = Quantity<usize, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for f32 {
    type Output = Quantity<f32, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
impl Mul<UnitNewtonsMul> for f64 {
    type Output = Quantity<f64, UnitNewtons>;
    fn mul(self, _: UnitNewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNewtons)
    }
}
pub struct UnitQuettanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettanewtons {
    #[inline]
    fn clone(&self) -> UnitQuettanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettanewtons {
    #[inline]
    fn eq(&self, other: &UnitQuettanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettanewtons {
    fn default() -> Self {
        UnitQuettanewtons
    }
}
impl Add<UnitQuettanewtons> for UnitQuettanewtons {
    type Output = UnitQuettanewtons;
    #[inline]
    fn add(self, _: UnitQuettanewtons) -> Self::Output {
        UnitQuettanewtons
    }
}
impl AddAssign<UnitQuettanewtons> for UnitQuettanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettanewtons) {}
}
impl Sub<UnitQuettanewtons> for UnitQuettanewtons {
    type Output = UnitQuettanewtons;
    #[inline]
    fn sub(self, _: UnitQuettanewtons) -> Self::Output {
        UnitQuettanewtons
    }
}
impl SubAssign<UnitQuettanewtons> for UnitQuettanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettanewtons) {}
}
pub struct UnitQuettanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitQuettanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for isize {
    type Output = Quantity<isize, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for usize {
    type Output = Quantity<usize, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
impl Mul<UnitQuettanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitQuettanewtons>;
    fn mul(self, _: UnitQuettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuettanewtons)
    }
}
pub struct UnitRonnanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnanewtons {
    #[inline]
    fn clone(&self) -> UnitRonnanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnanewtons {
    #[inline]
    fn eq(&self, other: &UnitRonnanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnanewtons {
    fn default() -> Self {
        UnitRonnanewtons
    }
}
impl Add<UnitRonnanewtons> for UnitRonnanewtons {
    type Output = UnitRonnanewtons;
    #[inline]
    fn add(self, _: UnitRonnanewtons) -> Self::Output {
        UnitRonnanewtons
    }
}
impl AddAssign<UnitRonnanewtons> for UnitRonnanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnanewtons) {}
}
impl Sub<UnitRonnanewtons> for UnitRonnanewtons {
    type Output = UnitRonnanewtons;
    #[inline]
    fn sub(self, _: UnitRonnanewtons) -> Self::Output {
        UnitRonnanewtons
    }
}
impl SubAssign<UnitRonnanewtons> for UnitRonnanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnanewtons) {}
}
pub struct UnitRonnanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitRonnanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for isize {
    type Output = Quantity<isize, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for usize {
    type Output = Quantity<usize, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
impl Mul<UnitRonnanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitRonnanewtons>;
    fn mul(self, _: UnitRonnanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRonnanewtons)
    }
}
pub struct UnitYottanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottanewtons {
    #[inline]
    fn clone(&self) -> UnitYottanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottanewtons {
    #[inline]
    fn eq(&self, other: &UnitYottanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottanewtons {
    fn default() -> Self {
        UnitYottanewtons
    }
}
impl Add<UnitYottanewtons> for UnitYottanewtons {
    type Output = UnitYottanewtons;
    #[inline]
    fn add(self, _: UnitYottanewtons) -> Self::Output {
        UnitYottanewtons
    }
}
impl AddAssign<UnitYottanewtons> for UnitYottanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitYottanewtons) {}
}
impl Sub<UnitYottanewtons> for UnitYottanewtons {
    type Output = UnitYottanewtons;
    #[inline]
    fn sub(self, _: UnitYottanewtons) -> Self::Output {
        UnitYottanewtons
    }
}
impl SubAssign<UnitYottanewtons> for UnitYottanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottanewtons) {}
}
pub struct UnitYottanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitYottanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitYottanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for isize {
    type Output = Quantity<isize, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for usize {
    type Output = Quantity<usize, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
impl Mul<UnitYottanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitYottanewtons>;
    fn mul(self, _: UnitYottanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYottanewtons)
    }
}
pub struct UnitZettanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettanewtons {
    #[inline]
    fn clone(&self) -> UnitZettanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettanewtons {
    #[inline]
    fn eq(&self, other: &UnitZettanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettanewtons {
    fn default() -> Self {
        UnitZettanewtons
    }
}
impl Add<UnitZettanewtons> for UnitZettanewtons {
    type Output = UnitZettanewtons;
    #[inline]
    fn add(self, _: UnitZettanewtons) -> Self::Output {
        UnitZettanewtons
    }
}
impl AddAssign<UnitZettanewtons> for UnitZettanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitZettanewtons) {}
}
impl Sub<UnitZettanewtons> for UnitZettanewtons {
    type Output = UnitZettanewtons;
    #[inline]
    fn sub(self, _: UnitZettanewtons) -> Self::Output {
        UnitZettanewtons
    }
}
impl SubAssign<UnitZettanewtons> for UnitZettanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettanewtons) {}
}
pub struct UnitZettanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitZettanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitZettanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for isize {
    type Output = Quantity<isize, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for usize {
    type Output = Quantity<usize, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
impl Mul<UnitZettanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitZettanewtons>;
    fn mul(self, _: UnitZettanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZettanewtons)
    }
}
pub struct UnitExanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExanewtons {
    #[inline]
    fn clone(&self) -> UnitExanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExanewtons {
    #[inline]
    fn eq(&self, other: &UnitExanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExanewtons {
    fn default() -> Self {
        UnitExanewtons
    }
}
impl Add<UnitExanewtons> for UnitExanewtons {
    type Output = UnitExanewtons;
    #[inline]
    fn add(self, _: UnitExanewtons) -> Self::Output {
        UnitExanewtons
    }
}
impl AddAssign<UnitExanewtons> for UnitExanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitExanewtons) {}
}
impl Sub<UnitExanewtons> for UnitExanewtons {
    type Output = UnitExanewtons;
    #[inline]
    fn sub(self, _: UnitExanewtons) -> Self::Output {
        UnitExanewtons
    }
}
impl SubAssign<UnitExanewtons> for UnitExanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitExanewtons) {}
}
pub struct UnitExanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitExanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitExanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for isize {
    type Output = Quantity<isize, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for usize {
    type Output = Quantity<usize, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
impl Mul<UnitExanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitExanewtons>;
    fn mul(self, _: UnitExanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitExanewtons)
    }
}
pub struct UnitPetanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetanewtons {
    #[inline]
    fn clone(&self) -> UnitPetanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetanewtons {
    #[inline]
    fn eq(&self, other: &UnitPetanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetanewtons {
    fn default() -> Self {
        UnitPetanewtons
    }
}
impl Add<UnitPetanewtons> for UnitPetanewtons {
    type Output = UnitPetanewtons;
    #[inline]
    fn add(self, _: UnitPetanewtons) -> Self::Output {
        UnitPetanewtons
    }
}
impl AddAssign<UnitPetanewtons> for UnitPetanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitPetanewtons) {}
}
impl Sub<UnitPetanewtons> for UnitPetanewtons {
    type Output = UnitPetanewtons;
    #[inline]
    fn sub(self, _: UnitPetanewtons) -> Self::Output {
        UnitPetanewtons
    }
}
impl SubAssign<UnitPetanewtons> for UnitPetanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetanewtons) {}
}
pub struct UnitPetanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitPetanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitPetanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for isize {
    type Output = Quantity<isize, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for usize {
    type Output = Quantity<usize, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
impl Mul<UnitPetanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitPetanewtons>;
    fn mul(self, _: UnitPetanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPetanewtons)
    }
}
pub struct UnitTeranewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeranewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeranewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeranewtons {
    #[inline]
    fn clone(&self) -> UnitTeranewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeranewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeranewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeranewtons {
    #[inline]
    fn eq(&self, other: &UnitTeranewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeranewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeranewtons {
    fn default() -> Self {
        UnitTeranewtons
    }
}
impl Add<UnitTeranewtons> for UnitTeranewtons {
    type Output = UnitTeranewtons;
    #[inline]
    fn add(self, _: UnitTeranewtons) -> Self::Output {
        UnitTeranewtons
    }
}
impl AddAssign<UnitTeranewtons> for UnitTeranewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitTeranewtons) {}
}
impl Sub<UnitTeranewtons> for UnitTeranewtons {
    type Output = UnitTeranewtons;
    #[inline]
    fn sub(self, _: UnitTeranewtons) -> Self::Output {
        UnitTeranewtons
    }
}
impl SubAssign<UnitTeranewtons> for UnitTeranewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeranewtons) {}
}
pub struct UnitTeranewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeranewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeranewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeranewtonsMul {
    #[inline]
    fn clone(&self) -> UnitTeranewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeranewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeranewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeranewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitTeranewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeranewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeranewtonsMul> for i8 {
    type Output = Quantity<i8, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for i16 {
    type Output = Quantity<i16, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for i32 {
    type Output = Quantity<i32, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for i64 {
    type Output = Quantity<i64, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for i128 {
    type Output = Quantity<i128, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for isize {
    type Output = Quantity<isize, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for u8 {
    type Output = Quantity<u8, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for u16 {
    type Output = Quantity<u16, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for u32 {
    type Output = Quantity<u32, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for u64 {
    type Output = Quantity<u64, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for u128 {
    type Output = Quantity<u128, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for usize {
    type Output = Quantity<usize, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for f32 {
    type Output = Quantity<f32, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
impl Mul<UnitTeranewtonsMul> for f64 {
    type Output = Quantity<f64, UnitTeranewtons>;
    fn mul(self, _: UnitTeranewtonsMul) -> Self::Output {
        Quantity::new(self, UnitTeranewtons)
    }
}
pub struct UnitGiganewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGiganewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGiganewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGiganewtons {
    #[inline]
    fn clone(&self) -> UnitGiganewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGiganewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGiganewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGiganewtons {
    #[inline]
    fn eq(&self, other: &UnitGiganewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGiganewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGiganewtons {
    fn default() -> Self {
        UnitGiganewtons
    }
}
impl Add<UnitGiganewtons> for UnitGiganewtons {
    type Output = UnitGiganewtons;
    #[inline]
    fn add(self, _: UnitGiganewtons) -> Self::Output {
        UnitGiganewtons
    }
}
impl AddAssign<UnitGiganewtons> for UnitGiganewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitGiganewtons) {}
}
impl Sub<UnitGiganewtons> for UnitGiganewtons {
    type Output = UnitGiganewtons;
    #[inline]
    fn sub(self, _: UnitGiganewtons) -> Self::Output {
        UnitGiganewtons
    }
}
impl SubAssign<UnitGiganewtons> for UnitGiganewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitGiganewtons) {}
}
pub struct UnitGiganewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGiganewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGiganewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGiganewtonsMul {
    #[inline]
    fn clone(&self) -> UnitGiganewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGiganewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGiganewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGiganewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitGiganewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGiganewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGiganewtonsMul> for i8 {
    type Output = Quantity<i8, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for i16 {
    type Output = Quantity<i16, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for i32 {
    type Output = Quantity<i32, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for i64 {
    type Output = Quantity<i64, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for i128 {
    type Output = Quantity<i128, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for isize {
    type Output = Quantity<isize, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for u8 {
    type Output = Quantity<u8, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for u16 {
    type Output = Quantity<u16, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for u32 {
    type Output = Quantity<u32, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for u64 {
    type Output = Quantity<u64, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for u128 {
    type Output = Quantity<u128, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for usize {
    type Output = Quantity<usize, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for f32 {
    type Output = Quantity<f32, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
impl Mul<UnitGiganewtonsMul> for f64 {
    type Output = Quantity<f64, UnitGiganewtons>;
    fn mul(self, _: UnitGiganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitGiganewtons)
    }
}
pub struct UnitMeganewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMeganewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMeganewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMeganewtons {
    #[inline]
    fn clone(&self) -> UnitMeganewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMeganewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMeganewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMeganewtons {
    #[inline]
    fn eq(&self, other: &UnitMeganewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMeganewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMeganewtons {
    fn default() -> Self {
        UnitMeganewtons
    }
}
impl Add<UnitMeganewtons> for UnitMeganewtons {
    type Output = UnitMeganewtons;
    #[inline]
    fn add(self, _: UnitMeganewtons) -> Self::Output {
        UnitMeganewtons
    }
}
impl AddAssign<UnitMeganewtons> for UnitMeganewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitMeganewtons) {}
}
impl Sub<UnitMeganewtons> for UnitMeganewtons {
    type Output = UnitMeganewtons;
    #[inline]
    fn sub(self, _: UnitMeganewtons) -> Self::Output {
        UnitMeganewtons
    }
}
impl SubAssign<UnitMeganewtons> for UnitMeganewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitMeganewtons) {}
}
pub struct UnitMeganewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMeganewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMeganewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMeganewtonsMul {
    #[inline]
    fn clone(&self) -> UnitMeganewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMeganewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMeganewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMeganewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitMeganewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMeganewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMeganewtonsMul> for i8 {
    type Output = Quantity<i8, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for i16 {
    type Output = Quantity<i16, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for i32 {
    type Output = Quantity<i32, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for i64 {
    type Output = Quantity<i64, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for i128 {
    type Output = Quantity<i128, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for isize {
    type Output = Quantity<isize, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for u8 {
    type Output = Quantity<u8, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for u16 {
    type Output = Quantity<u16, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for u32 {
    type Output = Quantity<u32, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for u64 {
    type Output = Quantity<u64, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for u128 {
    type Output = Quantity<u128, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for usize {
    type Output = Quantity<usize, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for f32 {
    type Output = Quantity<f32, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
impl Mul<UnitMeganewtonsMul> for f64 {
    type Output = Quantity<f64, UnitMeganewtons>;
    fn mul(self, _: UnitMeganewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMeganewtons)
    }
}
pub struct UnitKilonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilonewtons {
    #[inline]
    fn clone(&self) -> UnitKilonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilonewtons {
    #[inline]
    fn eq(&self, other: &UnitKilonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilonewtons {
    fn default() -> Self {
        UnitKilonewtons
    }
}
impl Add<UnitKilonewtons> for UnitKilonewtons {
    type Output = UnitKilonewtons;
    #[inline]
    fn add(self, _: UnitKilonewtons) -> Self::Output {
        UnitKilonewtons
    }
}
impl AddAssign<UnitKilonewtons> for UnitKilonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitKilonewtons) {}
}
impl Sub<UnitKilonewtons> for UnitKilonewtons {
    type Output = UnitKilonewtons;
    #[inline]
    fn sub(self, _: UnitKilonewtons) -> Self::Output {
        UnitKilonewtons
    }
}
impl SubAssign<UnitKilonewtons> for UnitKilonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilonewtons) {}
}
pub struct UnitKilonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitKilonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitKilonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for isize {
    type Output = Quantity<isize, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for usize {
    type Output = Quantity<usize, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
impl Mul<UnitKilonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitKilonewtons>;
    fn mul(self, _: UnitKilonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitKilonewtons)
    }
}
pub struct UnitHectonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectonewtons {
    #[inline]
    fn clone(&self) -> UnitHectonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectonewtons {
    #[inline]
    fn eq(&self, other: &UnitHectonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectonewtons {
    fn default() -> Self {
        UnitHectonewtons
    }
}
impl Add<UnitHectonewtons> for UnitHectonewtons {
    type Output = UnitHectonewtons;
    #[inline]
    fn add(self, _: UnitHectonewtons) -> Self::Output {
        UnitHectonewtons
    }
}
impl AddAssign<UnitHectonewtons> for UnitHectonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitHectonewtons) {}
}
impl Sub<UnitHectonewtons> for UnitHectonewtons {
    type Output = UnitHectonewtons;
    #[inline]
    fn sub(self, _: UnitHectonewtons) -> Self::Output {
        UnitHectonewtons
    }
}
impl SubAssign<UnitHectonewtons> for UnitHectonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectonewtons) {}
}
pub struct UnitHectonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitHectonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitHectonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for isize {
    type Output = Quantity<isize, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for usize {
    type Output = Quantity<usize, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
impl Mul<UnitHectonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitHectonewtons>;
    fn mul(self, _: UnitHectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitHectonewtons)
    }
}
pub struct UnitDecanewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecanewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecanewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecanewtons {
    #[inline]
    fn clone(&self) -> UnitDecanewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecanewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecanewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecanewtons {
    #[inline]
    fn eq(&self, other: &UnitDecanewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecanewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecanewtons {
    fn default() -> Self {
        UnitDecanewtons
    }
}
impl Add<UnitDecanewtons> for UnitDecanewtons {
    type Output = UnitDecanewtons;
    #[inline]
    fn add(self, _: UnitDecanewtons) -> Self::Output {
        UnitDecanewtons
    }
}
impl AddAssign<UnitDecanewtons> for UnitDecanewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitDecanewtons) {}
}
impl Sub<UnitDecanewtons> for UnitDecanewtons {
    type Output = UnitDecanewtons;
    #[inline]
    fn sub(self, _: UnitDecanewtons) -> Self::Output {
        UnitDecanewtons
    }
}
impl SubAssign<UnitDecanewtons> for UnitDecanewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecanewtons) {}
}
pub struct UnitDecanewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecanewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecanewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecanewtonsMul {
    #[inline]
    fn clone(&self) -> UnitDecanewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecanewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecanewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecanewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitDecanewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecanewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecanewtonsMul> for i8 {
    type Output = Quantity<i8, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for i16 {
    type Output = Quantity<i16, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for i32 {
    type Output = Quantity<i32, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for i64 {
    type Output = Quantity<i64, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for i128 {
    type Output = Quantity<i128, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for isize {
    type Output = Quantity<isize, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for u8 {
    type Output = Quantity<u8, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for u16 {
    type Output = Quantity<u16, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for u32 {
    type Output = Quantity<u32, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for u64 {
    type Output = Quantity<u64, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for u128 {
    type Output = Quantity<u128, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for usize {
    type Output = Quantity<usize, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for f32 {
    type Output = Quantity<f32, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
impl Mul<UnitDecanewtonsMul> for f64 {
    type Output = Quantity<f64, UnitDecanewtons>;
    fn mul(self, _: UnitDecanewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecanewtons)
    }
}
pub struct UnitDecinewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecinewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecinewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecinewtons {
    #[inline]
    fn clone(&self) -> UnitDecinewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecinewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecinewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecinewtons {
    #[inline]
    fn eq(&self, other: &UnitDecinewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecinewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecinewtons {
    fn default() -> Self {
        UnitDecinewtons
    }
}
impl Add<UnitDecinewtons> for UnitDecinewtons {
    type Output = UnitDecinewtons;
    #[inline]
    fn add(self, _: UnitDecinewtons) -> Self::Output {
        UnitDecinewtons
    }
}
impl AddAssign<UnitDecinewtons> for UnitDecinewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitDecinewtons) {}
}
impl Sub<UnitDecinewtons> for UnitDecinewtons {
    type Output = UnitDecinewtons;
    #[inline]
    fn sub(self, _: UnitDecinewtons) -> Self::Output {
        UnitDecinewtons
    }
}
impl SubAssign<UnitDecinewtons> for UnitDecinewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecinewtons) {}
}
pub struct UnitDecinewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecinewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecinewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecinewtonsMul {
    #[inline]
    fn clone(&self) -> UnitDecinewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecinewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecinewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecinewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitDecinewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecinewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecinewtonsMul> for i8 {
    type Output = Quantity<i8, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for i16 {
    type Output = Quantity<i16, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for i32 {
    type Output = Quantity<i32, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for i64 {
    type Output = Quantity<i64, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for i128 {
    type Output = Quantity<i128, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for isize {
    type Output = Quantity<isize, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for u8 {
    type Output = Quantity<u8, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for u16 {
    type Output = Quantity<u16, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for u32 {
    type Output = Quantity<u32, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for u64 {
    type Output = Quantity<u64, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for u128 {
    type Output = Quantity<u128, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for usize {
    type Output = Quantity<usize, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for f32 {
    type Output = Quantity<f32, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
impl Mul<UnitDecinewtonsMul> for f64 {
    type Output = Quantity<f64, UnitDecinewtons>;
    fn mul(self, _: UnitDecinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitDecinewtons)
    }
}
pub struct UnitCentinewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentinewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentinewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentinewtons {
    #[inline]
    fn clone(&self) -> UnitCentinewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentinewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentinewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentinewtons {
    #[inline]
    fn eq(&self, other: &UnitCentinewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentinewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentinewtons {
    fn default() -> Self {
        UnitCentinewtons
    }
}
impl Add<UnitCentinewtons> for UnitCentinewtons {
    type Output = UnitCentinewtons;
    #[inline]
    fn add(self, _: UnitCentinewtons) -> Self::Output {
        UnitCentinewtons
    }
}
impl AddAssign<UnitCentinewtons> for UnitCentinewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitCentinewtons) {}
}
impl Sub<UnitCentinewtons> for UnitCentinewtons {
    type Output = UnitCentinewtons;
    #[inline]
    fn sub(self, _: UnitCentinewtons) -> Self::Output {
        UnitCentinewtons
    }
}
impl SubAssign<UnitCentinewtons> for UnitCentinewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentinewtons) {}
}
pub struct UnitCentinewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentinewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentinewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentinewtonsMul {
    #[inline]
    fn clone(&self) -> UnitCentinewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentinewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentinewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentinewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitCentinewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentinewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentinewtonsMul> for i8 {
    type Output = Quantity<i8, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for i16 {
    type Output = Quantity<i16, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for i32 {
    type Output = Quantity<i32, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for i64 {
    type Output = Quantity<i64, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for i128 {
    type Output = Quantity<i128, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for isize {
    type Output = Quantity<isize, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for u8 {
    type Output = Quantity<u8, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for u16 {
    type Output = Quantity<u16, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for u32 {
    type Output = Quantity<u32, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for u64 {
    type Output = Quantity<u64, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for u128 {
    type Output = Quantity<u128, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for usize {
    type Output = Quantity<usize, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for f32 {
    type Output = Quantity<f32, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
impl Mul<UnitCentinewtonsMul> for f64 {
    type Output = Quantity<f64, UnitCentinewtons>;
    fn mul(self, _: UnitCentinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitCentinewtons)
    }
}
pub struct UnitMillinewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillinewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillinewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillinewtons {
    #[inline]
    fn clone(&self) -> UnitMillinewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillinewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillinewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillinewtons {
    #[inline]
    fn eq(&self, other: &UnitMillinewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillinewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillinewtons {
    fn default() -> Self {
        UnitMillinewtons
    }
}
impl Add<UnitMillinewtons> for UnitMillinewtons {
    type Output = UnitMillinewtons;
    #[inline]
    fn add(self, _: UnitMillinewtons) -> Self::Output {
        UnitMillinewtons
    }
}
impl AddAssign<UnitMillinewtons> for UnitMillinewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitMillinewtons) {}
}
impl Sub<UnitMillinewtons> for UnitMillinewtons {
    type Output = UnitMillinewtons;
    #[inline]
    fn sub(self, _: UnitMillinewtons) -> Self::Output {
        UnitMillinewtons
    }
}
impl SubAssign<UnitMillinewtons> for UnitMillinewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillinewtons) {}
}
pub struct UnitMillinewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillinewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillinewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillinewtonsMul {
    #[inline]
    fn clone(&self) -> UnitMillinewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillinewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillinewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillinewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitMillinewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillinewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillinewtonsMul> for i8 {
    type Output = Quantity<i8, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for i16 {
    type Output = Quantity<i16, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for i32 {
    type Output = Quantity<i32, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for i64 {
    type Output = Quantity<i64, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for i128 {
    type Output = Quantity<i128, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for isize {
    type Output = Quantity<isize, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for u8 {
    type Output = Quantity<u8, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for u16 {
    type Output = Quantity<u16, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for u32 {
    type Output = Quantity<u32, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for u64 {
    type Output = Quantity<u64, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for u128 {
    type Output = Quantity<u128, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for usize {
    type Output = Quantity<usize, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for f32 {
    type Output = Quantity<f32, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
impl Mul<UnitMillinewtonsMul> for f64 {
    type Output = Quantity<f64, UnitMillinewtons>;
    fn mul(self, _: UnitMillinewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMillinewtons)
    }
}
pub struct UnitMicronewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicronewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicronewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicronewtons {
    #[inline]
    fn clone(&self) -> UnitMicronewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicronewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicronewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicronewtons {
    #[inline]
    fn eq(&self, other: &UnitMicronewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicronewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicronewtons {
    fn default() -> Self {
        UnitMicronewtons
    }
}
impl Add<UnitMicronewtons> for UnitMicronewtons {
    type Output = UnitMicronewtons;
    #[inline]
    fn add(self, _: UnitMicronewtons) -> Self::Output {
        UnitMicronewtons
    }
}
impl AddAssign<UnitMicronewtons> for UnitMicronewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitMicronewtons) {}
}
impl Sub<UnitMicronewtons> for UnitMicronewtons {
    type Output = UnitMicronewtons;
    #[inline]
    fn sub(self, _: UnitMicronewtons) -> Self::Output {
        UnitMicronewtons
    }
}
impl SubAssign<UnitMicronewtons> for UnitMicronewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicronewtons) {}
}
pub struct UnitMicronewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicronewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicronewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicronewtonsMul {
    #[inline]
    fn clone(&self) -> UnitMicronewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicronewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicronewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicronewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitMicronewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicronewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicronewtonsMul> for i8 {
    type Output = Quantity<i8, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for i16 {
    type Output = Quantity<i16, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for i32 {
    type Output = Quantity<i32, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for i64 {
    type Output = Quantity<i64, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for i128 {
    type Output = Quantity<i128, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for isize {
    type Output = Quantity<isize, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for u8 {
    type Output = Quantity<u8, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for u16 {
    type Output = Quantity<u16, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for u32 {
    type Output = Quantity<u32, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for u64 {
    type Output = Quantity<u64, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for u128 {
    type Output = Quantity<u128, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for usize {
    type Output = Quantity<usize, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for f32 {
    type Output = Quantity<f32, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
impl Mul<UnitMicronewtonsMul> for f64 {
    type Output = Quantity<f64, UnitMicronewtons>;
    fn mul(self, _: UnitMicronewtonsMul) -> Self::Output {
        Quantity::new(self, UnitMicronewtons)
    }
}
pub struct UnitNanonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanonewtons {
    #[inline]
    fn clone(&self) -> UnitNanonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanonewtons {
    #[inline]
    fn eq(&self, other: &UnitNanonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanonewtons {
    fn default() -> Self {
        UnitNanonewtons
    }
}
impl Add<UnitNanonewtons> for UnitNanonewtons {
    type Output = UnitNanonewtons;
    #[inline]
    fn add(self, _: UnitNanonewtons) -> Self::Output {
        UnitNanonewtons
    }
}
impl AddAssign<UnitNanonewtons> for UnitNanonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitNanonewtons) {}
}
impl Sub<UnitNanonewtons> for UnitNanonewtons {
    type Output = UnitNanonewtons;
    #[inline]
    fn sub(self, _: UnitNanonewtons) -> Self::Output {
        UnitNanonewtons
    }
}
impl SubAssign<UnitNanonewtons> for UnitNanonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanonewtons) {}
}
pub struct UnitNanonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitNanonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitNanonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for isize {
    type Output = Quantity<isize, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for usize {
    type Output = Quantity<usize, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
impl Mul<UnitNanonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitNanonewtons>;
    fn mul(self, _: UnitNanonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitNanonewtons)
    }
}
pub struct UnitPiconewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPiconewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPiconewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPiconewtons {
    #[inline]
    fn clone(&self) -> UnitPiconewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPiconewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPiconewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPiconewtons {
    #[inline]
    fn eq(&self, other: &UnitPiconewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPiconewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPiconewtons {
    fn default() -> Self {
        UnitPiconewtons
    }
}
impl Add<UnitPiconewtons> for UnitPiconewtons {
    type Output = UnitPiconewtons;
    #[inline]
    fn add(self, _: UnitPiconewtons) -> Self::Output {
        UnitPiconewtons
    }
}
impl AddAssign<UnitPiconewtons> for UnitPiconewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitPiconewtons) {}
}
impl Sub<UnitPiconewtons> for UnitPiconewtons {
    type Output = UnitPiconewtons;
    #[inline]
    fn sub(self, _: UnitPiconewtons) -> Self::Output {
        UnitPiconewtons
    }
}
impl SubAssign<UnitPiconewtons> for UnitPiconewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitPiconewtons) {}
}
pub struct UnitPiconewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPiconewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPiconewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPiconewtonsMul {
    #[inline]
    fn clone(&self) -> UnitPiconewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPiconewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPiconewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPiconewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitPiconewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPiconewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPiconewtonsMul> for i8 {
    type Output = Quantity<i8, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for i16 {
    type Output = Quantity<i16, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for i32 {
    type Output = Quantity<i32, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for i64 {
    type Output = Quantity<i64, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for i128 {
    type Output = Quantity<i128, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for isize {
    type Output = Quantity<isize, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for u8 {
    type Output = Quantity<u8, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for u16 {
    type Output = Quantity<u16, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for u32 {
    type Output = Quantity<u32, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for u64 {
    type Output = Quantity<u64, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for u128 {
    type Output = Quantity<u128, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for usize {
    type Output = Quantity<usize, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for f32 {
    type Output = Quantity<f32, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
impl Mul<UnitPiconewtonsMul> for f64 {
    type Output = Quantity<f64, UnitPiconewtons>;
    fn mul(self, _: UnitPiconewtonsMul) -> Self::Output {
        Quantity::new(self, UnitPiconewtons)
    }
}
pub struct UnitFemtonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtonewtons {
    #[inline]
    fn clone(&self) -> UnitFemtonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtonewtons {
    #[inline]
    fn eq(&self, other: &UnitFemtonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtonewtons {
    fn default() -> Self {
        UnitFemtonewtons
    }
}
impl Add<UnitFemtonewtons> for UnitFemtonewtons {
    type Output = UnitFemtonewtons;
    #[inline]
    fn add(self, _: UnitFemtonewtons) -> Self::Output {
        UnitFemtonewtons
    }
}
impl AddAssign<UnitFemtonewtons> for UnitFemtonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtonewtons) {}
}
impl Sub<UnitFemtonewtons> for UnitFemtonewtons {
    type Output = UnitFemtonewtons;
    #[inline]
    fn sub(self, _: UnitFemtonewtons) -> Self::Output {
        UnitFemtonewtons
    }
}
impl SubAssign<UnitFemtonewtons> for UnitFemtonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtonewtons) {}
}
pub struct UnitFemtonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitFemtonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for isize {
    type Output = Quantity<isize, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for usize {
    type Output = Quantity<usize, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
impl Mul<UnitFemtonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitFemtonewtons>;
    fn mul(self, _: UnitFemtonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitFemtonewtons)
    }
}
pub struct UnitAttonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttonewtons {
    #[inline]
    fn clone(&self) -> UnitAttonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttonewtons {
    #[inline]
    fn eq(&self, other: &UnitAttonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttonewtons {
    fn default() -> Self {
        UnitAttonewtons
    }
}
impl Add<UnitAttonewtons> for UnitAttonewtons {
    type Output = UnitAttonewtons;
    #[inline]
    fn add(self, _: UnitAttonewtons) -> Self::Output {
        UnitAttonewtons
    }
}
impl AddAssign<UnitAttonewtons> for UnitAttonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitAttonewtons) {}
}
impl Sub<UnitAttonewtons> for UnitAttonewtons {
    type Output = UnitAttonewtons;
    #[inline]
    fn sub(self, _: UnitAttonewtons) -> Self::Output {
        UnitAttonewtons
    }
}
impl SubAssign<UnitAttonewtons> for UnitAttonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttonewtons) {}
}
pub struct UnitAttonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitAttonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitAttonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for isize {
    type Output = Quantity<isize, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for usize {
    type Output = Quantity<usize, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
impl Mul<UnitAttonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitAttonewtons>;
    fn mul(self, _: UnitAttonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitAttonewtons)
    }
}
pub struct UnitZeptonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptonewtons {
    #[inline]
    fn clone(&self) -> UnitZeptonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptonewtons {
    #[inline]
    fn eq(&self, other: &UnitZeptonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptonewtons {
    fn default() -> Self {
        UnitZeptonewtons
    }
}
impl Add<UnitZeptonewtons> for UnitZeptonewtons {
    type Output = UnitZeptonewtons;
    #[inline]
    fn add(self, _: UnitZeptonewtons) -> Self::Output {
        UnitZeptonewtons
    }
}
impl AddAssign<UnitZeptonewtons> for UnitZeptonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptonewtons) {}
}
impl Sub<UnitZeptonewtons> for UnitZeptonewtons {
    type Output = UnitZeptonewtons;
    #[inline]
    fn sub(self, _: UnitZeptonewtons) -> Self::Output {
        UnitZeptonewtons
    }
}
impl SubAssign<UnitZeptonewtons> for UnitZeptonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptonewtons) {}
}
pub struct UnitZeptonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitZeptonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for isize {
    type Output = Quantity<isize, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for usize {
    type Output = Quantity<usize, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
impl Mul<UnitZeptonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitZeptonewtons>;
    fn mul(self, _: UnitZeptonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitZeptonewtons)
    }
}
pub struct UnitYoctonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctonewtons {
    #[inline]
    fn clone(&self) -> UnitYoctonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctonewtons {
    #[inline]
    fn eq(&self, other: &UnitYoctonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctonewtons {
    fn default() -> Self {
        UnitYoctonewtons
    }
}
impl Add<UnitYoctonewtons> for UnitYoctonewtons {
    type Output = UnitYoctonewtons;
    #[inline]
    fn add(self, _: UnitYoctonewtons) -> Self::Output {
        UnitYoctonewtons
    }
}
impl AddAssign<UnitYoctonewtons> for UnitYoctonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctonewtons) {}
}
impl Sub<UnitYoctonewtons> for UnitYoctonewtons {
    type Output = UnitYoctonewtons;
    #[inline]
    fn sub(self, _: UnitYoctonewtons) -> Self::Output {
        UnitYoctonewtons
    }
}
impl SubAssign<UnitYoctonewtons> for UnitYoctonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctonewtons) {}
}
pub struct UnitYoctonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitYoctonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for isize {
    type Output = Quantity<isize, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for usize {
    type Output = Quantity<usize, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
impl Mul<UnitYoctonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitYoctonewtons>;
    fn mul(self, _: UnitYoctonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitYoctonewtons)
    }
}
pub struct UnitRontonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontonewtons {
    #[inline]
    fn clone(&self) -> UnitRontonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontonewtons {
    #[inline]
    fn eq(&self, other: &UnitRontonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontonewtons {
    fn default() -> Self {
        UnitRontonewtons
    }
}
impl Add<UnitRontonewtons> for UnitRontonewtons {
    type Output = UnitRontonewtons;
    #[inline]
    fn add(self, _: UnitRontonewtons) -> Self::Output {
        UnitRontonewtons
    }
}
impl AddAssign<UnitRontonewtons> for UnitRontonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitRontonewtons) {}
}
impl Sub<UnitRontonewtons> for UnitRontonewtons {
    type Output = UnitRontonewtons;
    #[inline]
    fn sub(self, _: UnitRontonewtons) -> Self::Output {
        UnitRontonewtons
    }
}
impl SubAssign<UnitRontonewtons> for UnitRontonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontonewtons) {}
}
pub struct UnitRontonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitRontonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitRontonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for isize {
    type Output = Quantity<isize, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for usize {
    type Output = Quantity<usize, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
impl Mul<UnitRontonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitRontonewtons>;
    fn mul(self, _: UnitRontonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitRontonewtons)
    }
}
pub struct UnitQuectonewtons;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectonewtons {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectonewtons")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectonewtons {
    #[inline]
    fn clone(&self) -> UnitQuectonewtons {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectonewtons {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectonewtons {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectonewtons {
    #[inline]
    fn eq(&self, other: &UnitQuectonewtons) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectonewtons {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectonewtons {
    fn default() -> Self {
        UnitQuectonewtons
    }
}
impl Add<UnitQuectonewtons> for UnitQuectonewtons {
    type Output = UnitQuectonewtons;
    #[inline]
    fn add(self, _: UnitQuectonewtons) -> Self::Output {
        UnitQuectonewtons
    }
}
impl AddAssign<UnitQuectonewtons> for UnitQuectonewtons {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectonewtons) {}
}
impl Sub<UnitQuectonewtons> for UnitQuectonewtons {
    type Output = UnitQuectonewtons;
    #[inline]
    fn sub(self, _: UnitQuectonewtons) -> Self::Output {
        UnitQuectonewtons
    }
}
impl SubAssign<UnitQuectonewtons> for UnitQuectonewtons {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectonewtons) {}
}
pub struct UnitQuectonewtonsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectonewtonsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectonewtonsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectonewtonsMul {
    #[inline]
    fn clone(&self) -> UnitQuectonewtonsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectonewtonsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectonewtonsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectonewtonsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectonewtonsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectonewtonsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectonewtonsMul> for i8 {
    type Output = Quantity<i8, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for i16 {
    type Output = Quantity<i16, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for i32 {
    type Output = Quantity<i32, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for i64 {
    type Output = Quantity<i64, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for i128 {
    type Output = Quantity<i128, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for isize {
    type Output = Quantity<isize, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for u8 {
    type Output = Quantity<u8, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for u16 {
    type Output = Quantity<u16, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for u32 {
    type Output = Quantity<u32, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for u64 {
    type Output = Quantity<u64, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for u128 {
    type Output = Quantity<u128, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for usize {
    type Output = Quantity<usize, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for f32 {
    type Output = Quantity<f32, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
impl Mul<UnitQuectonewtonsMul> for f64 {
    type Output = Quantity<f64, UnitQuectonewtons>;
    fn mul(self, _: UnitQuectonewtonsMul) -> Self::Output {
        Quantity::new(self, UnitQuectonewtons)
    }
}
pub type Newtons<T> = Quantity<T, UnitNewtons>;
#[allow(non_upper_case_globals)]
pub static Newtons: UnitNewtonsMul = UnitNewtonsMul;
pub type Quettanewtons<T> = Quantity<T, UnitQuettanewtons>;
#[allow(non_upper_case_globals)]
pub static Quettanewtons: UnitQuettanewtonsMul = UnitQuettanewtonsMul;
pub type Ronnanewtons<T> = Quantity<T, UnitRonnanewtons>;
#[allow(non_upper_case_globals)]
pub static Ronnanewtons: UnitRonnanewtonsMul = UnitRonnanewtonsMul;
pub type Yottanewtons<T> = Quantity<T, UnitYottanewtons>;
#[allow(non_upper_case_globals)]
pub static Yottanewtons: UnitYottanewtonsMul = UnitYottanewtonsMul;
pub type Zettanewtons<T> = Quantity<T, UnitZettanewtons>;
#[allow(non_upper_case_globals)]
pub static Zettanewtons: UnitZettanewtonsMul = UnitZettanewtonsMul;
pub type Exanewtons<T> = Quantity<T, UnitExanewtons>;
#[allow(non_upper_case_globals)]
pub static Exanewtons: UnitExanewtonsMul = UnitExanewtonsMul;
pub type Petanewtons<T> = Quantity<T, UnitPetanewtons>;
#[allow(non_upper_case_globals)]
pub static Petanewtons: UnitPetanewtonsMul = UnitPetanewtonsMul;
pub type Teranewtons<T> = Quantity<T, UnitTeranewtons>;
#[allow(non_upper_case_globals)]
pub static Teranewtons: UnitTeranewtonsMul = UnitTeranewtonsMul;
pub type Giganewtons<T> = Quantity<T, UnitGiganewtons>;
#[allow(non_upper_case_globals)]
pub static Giganewtons: UnitGiganewtonsMul = UnitGiganewtonsMul;
pub type Meganewtons<T> = Quantity<T, UnitMeganewtons>;
#[allow(non_upper_case_globals)]
pub static Meganewtons: UnitMeganewtonsMul = UnitMeganewtonsMul;
pub type Kilonewtons<T> = Quantity<T, UnitKilonewtons>;
#[allow(non_upper_case_globals)]
pub static Kilonewtons: UnitKilonewtonsMul = UnitKilonewtonsMul;
pub type Hectonewtons<T> = Quantity<T, UnitHectonewtons>;
#[allow(non_upper_case_globals)]
pub static Hectonewtons: UnitHectonewtonsMul = UnitHectonewtonsMul;
pub type Decanewtons<T> = Quantity<T, UnitDecanewtons>;
#[allow(non_upper_case_globals)]
pub static Decanewtons: UnitDecanewtonsMul = UnitDecanewtonsMul;
pub type Decinewtons<T> = Quantity<T, UnitDecinewtons>;
#[allow(non_upper_case_globals)]
pub static Decinewtons: UnitDecinewtonsMul = UnitDecinewtonsMul;
pub type Centinewtons<T> = Quantity<T, UnitCentinewtons>;
#[allow(non_upper_case_globals)]
pub static Centinewtons: UnitCentinewtonsMul = UnitCentinewtonsMul;
pub type Millinewtons<T> = Quantity<T, UnitMillinewtons>;
#[allow(non_upper_case_globals)]
pub static Millinewtons: UnitMillinewtonsMul = UnitMillinewtonsMul;
pub type Micronewtons<T> = Quantity<T, UnitMicronewtons>;
#[allow(non_upper_case_globals)]
pub static Micronewtons: UnitMicronewtonsMul = UnitMicronewtonsMul;
pub type Nanonewtons<T> = Quantity<T, UnitNanonewtons>;
#[allow(non_upper_case_globals)]
pub static Nanonewtons: UnitNanonewtonsMul = UnitNanonewtonsMul;
pub type Piconewtons<T> = Quantity<T, UnitPiconewtons>;
#[allow(non_upper_case_globals)]
pub static Piconewtons: UnitPiconewtonsMul = UnitPiconewtonsMul;
pub type Femtonewtons<T> = Quantity<T, UnitFemtonewtons>;
#[allow(non_upper_case_globals)]
pub static Femtonewtons: UnitFemtonewtonsMul = UnitFemtonewtonsMul;
pub type Attonewtons<T> = Quantity<T, UnitAttonewtons>;
#[allow(non_upper_case_globals)]
pub static Attonewtons: UnitAttonewtonsMul = UnitAttonewtonsMul;
pub type Zeptonewtons<T> = Quantity<T, UnitZeptonewtons>;
#[allow(non_upper_case_globals)]
pub static Zeptonewtons: UnitZeptonewtonsMul = UnitZeptonewtonsMul;
pub type Yoctonewtons<T> = Quantity<T, UnitYoctonewtons>;
#[allow(non_upper_case_globals)]
pub static Yoctonewtons: UnitYoctonewtonsMul = UnitYoctonewtonsMul;
pub type Rontonewtons<T> = Quantity<T, UnitRontonewtons>;
#[allow(non_upper_case_globals)]
pub static Rontonewtons: UnitRontonewtonsMul = UnitRontonewtonsMul;
pub type Quectonewtons<T> = Quantity<T, UnitQuectonewtons>;
#[allow(non_upper_case_globals)]
pub static Quectonewtons: UnitQuectonewtonsMul = UnitQuectonewtonsMul;
pub struct UnitPascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPascals {
    #[inline]
    fn clone(&self) -> UnitPascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPascals {
    #[inline]
    fn eq(&self, other: &UnitPascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPascals {
    fn default() -> Self {
        UnitPascals
    }
}
impl Add<UnitPascals> for UnitPascals {
    type Output = UnitPascals;
    #[inline]
    fn add(self, _: UnitPascals) -> Self::Output {
        UnitPascals
    }
}
impl AddAssign<UnitPascals> for UnitPascals {
    #[inline]
    fn add_assign(&mut self, _: UnitPascals) {}
}
impl Sub<UnitPascals> for UnitPascals {
    type Output = UnitPascals;
    #[inline]
    fn sub(self, _: UnitPascals) -> Self::Output {
        UnitPascals
    }
}
impl SubAssign<UnitPascals> for UnitPascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPascals) {}
}
pub struct UnitPascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPascalsMul {
    #[inline]
    fn clone(&self) -> UnitPascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPascalsMul {
    #[inline]
    fn eq(&self, other: &UnitPascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPascalsMul> for i8 {
    type Output = Quantity<i8, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for i16 {
    type Output = Quantity<i16, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for i32 {
    type Output = Quantity<i32, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for i64 {
    type Output = Quantity<i64, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for i128 {
    type Output = Quantity<i128, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for isize {
    type Output = Quantity<isize, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for u8 {
    type Output = Quantity<u8, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for u16 {
    type Output = Quantity<u16, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for u32 {
    type Output = Quantity<u32, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for u64 {
    type Output = Quantity<u64, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for u128 {
    type Output = Quantity<u128, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for usize {
    type Output = Quantity<usize, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for f32 {
    type Output = Quantity<f32, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
impl Mul<UnitPascalsMul> for f64 {
    type Output = Quantity<f64, UnitPascals>;
    fn mul(self, _: UnitPascalsMul) -> Self::Output {
        Quantity::new(self, UnitPascals)
    }
}
pub struct UnitQuettapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettapascals {
    #[inline]
    fn clone(&self) -> UnitQuettapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettapascals {
    #[inline]
    fn eq(&self, other: &UnitQuettapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettapascals {
    fn default() -> Self {
        UnitQuettapascals
    }
}
impl Add<UnitQuettapascals> for UnitQuettapascals {
    type Output = UnitQuettapascals;
    #[inline]
    fn add(self, _: UnitQuettapascals) -> Self::Output {
        UnitQuettapascals
    }
}
impl AddAssign<UnitQuettapascals> for UnitQuettapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettapascals) {}
}
impl Sub<UnitQuettapascals> for UnitQuettapascals {
    type Output = UnitQuettapascals;
    #[inline]
    fn sub(self, _: UnitQuettapascals) -> Self::Output {
        UnitQuettapascals
    }
}
impl SubAssign<UnitQuettapascals> for UnitQuettapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettapascals) {}
}
pub struct UnitQuettapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettapascalsMul {
    #[inline]
    fn clone(&self) -> UnitQuettapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettapascalsMul> for i8 {
    type Output = Quantity<i8, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for i16 {
    type Output = Quantity<i16, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for i32 {
    type Output = Quantity<i32, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for i64 {
    type Output = Quantity<i64, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for i128 {
    type Output = Quantity<i128, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for isize {
    type Output = Quantity<isize, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for u8 {
    type Output = Quantity<u8, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for u16 {
    type Output = Quantity<u16, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for u32 {
    type Output = Quantity<u32, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for u64 {
    type Output = Quantity<u64, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for u128 {
    type Output = Quantity<u128, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for usize {
    type Output = Quantity<usize, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for f32 {
    type Output = Quantity<f32, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
impl Mul<UnitQuettapascalsMul> for f64 {
    type Output = Quantity<f64, UnitQuettapascals>;
    fn mul(self, _: UnitQuettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettapascals)
    }
}
pub struct UnitRonnapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnapascals {
    #[inline]
    fn clone(&self) -> UnitRonnapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnapascals {
    #[inline]
    fn eq(&self, other: &UnitRonnapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnapascals {
    fn default() -> Self {
        UnitRonnapascals
    }
}
impl Add<UnitRonnapascals> for UnitRonnapascals {
    type Output = UnitRonnapascals;
    #[inline]
    fn add(self, _: UnitRonnapascals) -> Self::Output {
        UnitRonnapascals
    }
}
impl AddAssign<UnitRonnapascals> for UnitRonnapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnapascals) {}
}
impl Sub<UnitRonnapascals> for UnitRonnapascals {
    type Output = UnitRonnapascals;
    #[inline]
    fn sub(self, _: UnitRonnapascals) -> Self::Output {
        UnitRonnapascals
    }
}
impl SubAssign<UnitRonnapascals> for UnitRonnapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnapascals) {}
}
pub struct UnitRonnapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnapascalsMul {
    #[inline]
    fn clone(&self) -> UnitRonnapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnapascalsMul> for i8 {
    type Output = Quantity<i8, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for i16 {
    type Output = Quantity<i16, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for i32 {
    type Output = Quantity<i32, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for i64 {
    type Output = Quantity<i64, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for i128 {
    type Output = Quantity<i128, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for isize {
    type Output = Quantity<isize, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for u8 {
    type Output = Quantity<u8, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for u16 {
    type Output = Quantity<u16, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for u32 {
    type Output = Quantity<u32, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for u64 {
    type Output = Quantity<u64, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for u128 {
    type Output = Quantity<u128, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for usize {
    type Output = Quantity<usize, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for f32 {
    type Output = Quantity<f32, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
impl Mul<UnitRonnapascalsMul> for f64 {
    type Output = Quantity<f64, UnitRonnapascals>;
    fn mul(self, _: UnitRonnapascalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnapascals)
    }
}
pub struct UnitYottapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottapascals {
    #[inline]
    fn clone(&self) -> UnitYottapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottapascals {
    #[inline]
    fn eq(&self, other: &UnitYottapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottapascals {
    fn default() -> Self {
        UnitYottapascals
    }
}
impl Add<UnitYottapascals> for UnitYottapascals {
    type Output = UnitYottapascals;
    #[inline]
    fn add(self, _: UnitYottapascals) -> Self::Output {
        UnitYottapascals
    }
}
impl AddAssign<UnitYottapascals> for UnitYottapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitYottapascals) {}
}
impl Sub<UnitYottapascals> for UnitYottapascals {
    type Output = UnitYottapascals;
    #[inline]
    fn sub(self, _: UnitYottapascals) -> Self::Output {
        UnitYottapascals
    }
}
impl SubAssign<UnitYottapascals> for UnitYottapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottapascals) {}
}
pub struct UnitYottapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottapascalsMul {
    #[inline]
    fn clone(&self) -> UnitYottapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitYottapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottapascalsMul> for i8 {
    type Output = Quantity<i8, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for i16 {
    type Output = Quantity<i16, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for i32 {
    type Output = Quantity<i32, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for i64 {
    type Output = Quantity<i64, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for i128 {
    type Output = Quantity<i128, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for isize {
    type Output = Quantity<isize, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for u8 {
    type Output = Quantity<u8, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for u16 {
    type Output = Quantity<u16, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for u32 {
    type Output = Quantity<u32, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for u64 {
    type Output = Quantity<u64, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for u128 {
    type Output = Quantity<u128, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for usize {
    type Output = Quantity<usize, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for f32 {
    type Output = Quantity<f32, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
impl Mul<UnitYottapascalsMul> for f64 {
    type Output = Quantity<f64, UnitYottapascals>;
    fn mul(self, _: UnitYottapascalsMul) -> Self::Output {
        Quantity::new(self, UnitYottapascals)
    }
}
pub struct UnitZettapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettapascals {
    #[inline]
    fn clone(&self) -> UnitZettapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettapascals {
    #[inline]
    fn eq(&self, other: &UnitZettapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettapascals {
    fn default() -> Self {
        UnitZettapascals
    }
}
impl Add<UnitZettapascals> for UnitZettapascals {
    type Output = UnitZettapascals;
    #[inline]
    fn add(self, _: UnitZettapascals) -> Self::Output {
        UnitZettapascals
    }
}
impl AddAssign<UnitZettapascals> for UnitZettapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitZettapascals) {}
}
impl Sub<UnitZettapascals> for UnitZettapascals {
    type Output = UnitZettapascals;
    #[inline]
    fn sub(self, _: UnitZettapascals) -> Self::Output {
        UnitZettapascals
    }
}
impl SubAssign<UnitZettapascals> for UnitZettapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettapascals) {}
}
pub struct UnitZettapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettapascalsMul {
    #[inline]
    fn clone(&self) -> UnitZettapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitZettapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettapascalsMul> for i8 {
    type Output = Quantity<i8, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for i16 {
    type Output = Quantity<i16, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for i32 {
    type Output = Quantity<i32, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for i64 {
    type Output = Quantity<i64, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for i128 {
    type Output = Quantity<i128, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for isize {
    type Output = Quantity<isize, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for u8 {
    type Output = Quantity<u8, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for u16 {
    type Output = Quantity<u16, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for u32 {
    type Output = Quantity<u32, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for u64 {
    type Output = Quantity<u64, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for u128 {
    type Output = Quantity<u128, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for usize {
    type Output = Quantity<usize, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for f32 {
    type Output = Quantity<f32, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
impl Mul<UnitZettapascalsMul> for f64 {
    type Output = Quantity<f64, UnitZettapascals>;
    fn mul(self, _: UnitZettapascalsMul) -> Self::Output {
        Quantity::new(self, UnitZettapascals)
    }
}
pub struct UnitExapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExapascals {
    #[inline]
    fn clone(&self) -> UnitExapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExapascals {
    #[inline]
    fn eq(&self, other: &UnitExapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExapascals {
    fn default() -> Self {
        UnitExapascals
    }
}
impl Add<UnitExapascals> for UnitExapascals {
    type Output = UnitExapascals;
    #[inline]
    fn add(self, _: UnitExapascals) -> Self::Output {
        UnitExapascals
    }
}
impl AddAssign<UnitExapascals> for UnitExapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitExapascals) {}
}
impl Sub<UnitExapascals> for UnitExapascals {
    type Output = UnitExapascals;
    #[inline]
    fn sub(self, _: UnitExapascals) -> Self::Output {
        UnitExapascals
    }
}
impl SubAssign<UnitExapascals> for UnitExapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitExapascals) {}
}
pub struct UnitExapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExapascalsMul {
    #[inline]
    fn clone(&self) -> UnitExapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitExapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExapascalsMul> for i8 {
    type Output = Quantity<i8, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for i16 {
    type Output = Quantity<i16, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for i32 {
    type Output = Quantity<i32, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for i64 {
    type Output = Quantity<i64, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for i128 {
    type Output = Quantity<i128, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for isize {
    type Output = Quantity<isize, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for u8 {
    type Output = Quantity<u8, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for u16 {
    type Output = Quantity<u16, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for u32 {
    type Output = Quantity<u32, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for u64 {
    type Output = Quantity<u64, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for u128 {
    type Output = Quantity<u128, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for usize {
    type Output = Quantity<usize, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for f32 {
    type Output = Quantity<f32, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
impl Mul<UnitExapascalsMul> for f64 {
    type Output = Quantity<f64, UnitExapascals>;
    fn mul(self, _: UnitExapascalsMul) -> Self::Output {
        Quantity::new(self, UnitExapascals)
    }
}
pub struct UnitPetapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetapascals {
    #[inline]
    fn clone(&self) -> UnitPetapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetapascals {
    #[inline]
    fn eq(&self, other: &UnitPetapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetapascals {
    fn default() -> Self {
        UnitPetapascals
    }
}
impl Add<UnitPetapascals> for UnitPetapascals {
    type Output = UnitPetapascals;
    #[inline]
    fn add(self, _: UnitPetapascals) -> Self::Output {
        UnitPetapascals
    }
}
impl AddAssign<UnitPetapascals> for UnitPetapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitPetapascals) {}
}
impl Sub<UnitPetapascals> for UnitPetapascals {
    type Output = UnitPetapascals;
    #[inline]
    fn sub(self, _: UnitPetapascals) -> Self::Output {
        UnitPetapascals
    }
}
impl SubAssign<UnitPetapascals> for UnitPetapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetapascals) {}
}
pub struct UnitPetapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetapascalsMul {
    #[inline]
    fn clone(&self) -> UnitPetapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitPetapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetapascalsMul> for i8 {
    type Output = Quantity<i8, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for i16 {
    type Output = Quantity<i16, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for i32 {
    type Output = Quantity<i32, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for i64 {
    type Output = Quantity<i64, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for i128 {
    type Output = Quantity<i128, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for isize {
    type Output = Quantity<isize, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for u8 {
    type Output = Quantity<u8, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for u16 {
    type Output = Quantity<u16, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for u32 {
    type Output = Quantity<u32, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for u64 {
    type Output = Quantity<u64, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for u128 {
    type Output = Quantity<u128, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for usize {
    type Output = Quantity<usize, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for f32 {
    type Output = Quantity<f32, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
impl Mul<UnitPetapascalsMul> for f64 {
    type Output = Quantity<f64, UnitPetapascals>;
    fn mul(self, _: UnitPetapascalsMul) -> Self::Output {
        Quantity::new(self, UnitPetapascals)
    }
}
pub struct UnitTerapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerapascals {
    #[inline]
    fn clone(&self) -> UnitTerapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerapascals {
    #[inline]
    fn eq(&self, other: &UnitTerapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerapascals {
    fn default() -> Self {
        UnitTerapascals
    }
}
impl Add<UnitTerapascals> for UnitTerapascals {
    type Output = UnitTerapascals;
    #[inline]
    fn add(self, _: UnitTerapascals) -> Self::Output {
        UnitTerapascals
    }
}
impl AddAssign<UnitTerapascals> for UnitTerapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitTerapascals) {}
}
impl Sub<UnitTerapascals> for UnitTerapascals {
    type Output = UnitTerapascals;
    #[inline]
    fn sub(self, _: UnitTerapascals) -> Self::Output {
        UnitTerapascals
    }
}
impl SubAssign<UnitTerapascals> for UnitTerapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerapascals) {}
}
pub struct UnitTerapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerapascalsMul {
    #[inline]
    fn clone(&self) -> UnitTerapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitTerapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerapascalsMul> for i8 {
    type Output = Quantity<i8, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for i16 {
    type Output = Quantity<i16, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for i32 {
    type Output = Quantity<i32, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for i64 {
    type Output = Quantity<i64, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for i128 {
    type Output = Quantity<i128, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for isize {
    type Output = Quantity<isize, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for u8 {
    type Output = Quantity<u8, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for u16 {
    type Output = Quantity<u16, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for u32 {
    type Output = Quantity<u32, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for u64 {
    type Output = Quantity<u64, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for u128 {
    type Output = Quantity<u128, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for usize {
    type Output = Quantity<usize, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for f32 {
    type Output = Quantity<f32, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
impl Mul<UnitTerapascalsMul> for f64 {
    type Output = Quantity<f64, UnitTerapascals>;
    fn mul(self, _: UnitTerapascalsMul) -> Self::Output {
        Quantity::new(self, UnitTerapascals)
    }
}
pub struct UnitGigapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigapascals {
    #[inline]
    fn clone(&self) -> UnitGigapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigapascals {
    #[inline]
    fn eq(&self, other: &UnitGigapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigapascals {
    fn default() -> Self {
        UnitGigapascals
    }
}
impl Add<UnitGigapascals> for UnitGigapascals {
    type Output = UnitGigapascals;
    #[inline]
    fn add(self, _: UnitGigapascals) -> Self::Output {
        UnitGigapascals
    }
}
impl AddAssign<UnitGigapascals> for UnitGigapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitGigapascals) {}
}
impl Sub<UnitGigapascals> for UnitGigapascals {
    type Output = UnitGigapascals;
    #[inline]
    fn sub(self, _: UnitGigapascals) -> Self::Output {
        UnitGigapascals
    }
}
impl SubAssign<UnitGigapascals> for UnitGigapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigapascals) {}
}
pub struct UnitGigapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigapascalsMul {
    #[inline]
    fn clone(&self) -> UnitGigapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitGigapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigapascalsMul> for i8 {
    type Output = Quantity<i8, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for i16 {
    type Output = Quantity<i16, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for i32 {
    type Output = Quantity<i32, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for i64 {
    type Output = Quantity<i64, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for i128 {
    type Output = Quantity<i128, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for isize {
    type Output = Quantity<isize, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for u8 {
    type Output = Quantity<u8, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for u16 {
    type Output = Quantity<u16, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for u32 {
    type Output = Quantity<u32, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for u64 {
    type Output = Quantity<u64, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for u128 {
    type Output = Quantity<u128, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for usize {
    type Output = Quantity<usize, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for f32 {
    type Output = Quantity<f32, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
impl Mul<UnitGigapascalsMul> for f64 {
    type Output = Quantity<f64, UnitGigapascals>;
    fn mul(self, _: UnitGigapascalsMul) -> Self::Output {
        Quantity::new(self, UnitGigapascals)
    }
}
pub struct UnitMegapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegapascals {
    #[inline]
    fn clone(&self) -> UnitMegapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegapascals {
    #[inline]
    fn eq(&self, other: &UnitMegapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegapascals {
    fn default() -> Self {
        UnitMegapascals
    }
}
impl Add<UnitMegapascals> for UnitMegapascals {
    type Output = UnitMegapascals;
    #[inline]
    fn add(self, _: UnitMegapascals) -> Self::Output {
        UnitMegapascals
    }
}
impl AddAssign<UnitMegapascals> for UnitMegapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitMegapascals) {}
}
impl Sub<UnitMegapascals> for UnitMegapascals {
    type Output = UnitMegapascals;
    #[inline]
    fn sub(self, _: UnitMegapascals) -> Self::Output {
        UnitMegapascals
    }
}
impl SubAssign<UnitMegapascals> for UnitMegapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegapascals) {}
}
pub struct UnitMegapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegapascalsMul {
    #[inline]
    fn clone(&self) -> UnitMegapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitMegapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegapascalsMul> for i8 {
    type Output = Quantity<i8, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for i16 {
    type Output = Quantity<i16, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for i32 {
    type Output = Quantity<i32, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for i64 {
    type Output = Quantity<i64, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for i128 {
    type Output = Quantity<i128, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for isize {
    type Output = Quantity<isize, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for u8 {
    type Output = Quantity<u8, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for u16 {
    type Output = Quantity<u16, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for u32 {
    type Output = Quantity<u32, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for u64 {
    type Output = Quantity<u64, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for u128 {
    type Output = Quantity<u128, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for usize {
    type Output = Quantity<usize, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for f32 {
    type Output = Quantity<f32, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
impl Mul<UnitMegapascalsMul> for f64 {
    type Output = Quantity<f64, UnitMegapascals>;
    fn mul(self, _: UnitMegapascalsMul) -> Self::Output {
        Quantity::new(self, UnitMegapascals)
    }
}
pub struct UnitKilopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilopascals {
    #[inline]
    fn clone(&self) -> UnitKilopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilopascals {
    #[inline]
    fn eq(&self, other: &UnitKilopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilopascals {
    fn default() -> Self {
        UnitKilopascals
    }
}
impl Add<UnitKilopascals> for UnitKilopascals {
    type Output = UnitKilopascals;
    #[inline]
    fn add(self, _: UnitKilopascals) -> Self::Output {
        UnitKilopascals
    }
}
impl AddAssign<UnitKilopascals> for UnitKilopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitKilopascals) {}
}
impl Sub<UnitKilopascals> for UnitKilopascals {
    type Output = UnitKilopascals;
    #[inline]
    fn sub(self, _: UnitKilopascals) -> Self::Output {
        UnitKilopascals
    }
}
impl SubAssign<UnitKilopascals> for UnitKilopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilopascals) {}
}
pub struct UnitKilopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilopascalsMul {
    #[inline]
    fn clone(&self) -> UnitKilopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitKilopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilopascalsMul> for i8 {
    type Output = Quantity<i8, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for i16 {
    type Output = Quantity<i16, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for i32 {
    type Output = Quantity<i32, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for i64 {
    type Output = Quantity<i64, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for i128 {
    type Output = Quantity<i128, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for isize {
    type Output = Quantity<isize, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for u8 {
    type Output = Quantity<u8, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for u16 {
    type Output = Quantity<u16, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for u32 {
    type Output = Quantity<u32, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for u64 {
    type Output = Quantity<u64, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for u128 {
    type Output = Quantity<u128, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for usize {
    type Output = Quantity<usize, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for f32 {
    type Output = Quantity<f32, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
impl Mul<UnitKilopascalsMul> for f64 {
    type Output = Quantity<f64, UnitKilopascals>;
    fn mul(self, _: UnitKilopascalsMul) -> Self::Output {
        Quantity::new(self, UnitKilopascals)
    }
}
pub struct UnitHectopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectopascals {
    #[inline]
    fn clone(&self) -> UnitHectopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectopascals {
    #[inline]
    fn eq(&self, other: &UnitHectopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectopascals {
    fn default() -> Self {
        UnitHectopascals
    }
}
impl Add<UnitHectopascals> for UnitHectopascals {
    type Output = UnitHectopascals;
    #[inline]
    fn add(self, _: UnitHectopascals) -> Self::Output {
        UnitHectopascals
    }
}
impl AddAssign<UnitHectopascals> for UnitHectopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitHectopascals) {}
}
impl Sub<UnitHectopascals> for UnitHectopascals {
    type Output = UnitHectopascals;
    #[inline]
    fn sub(self, _: UnitHectopascals) -> Self::Output {
        UnitHectopascals
    }
}
impl SubAssign<UnitHectopascals> for UnitHectopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectopascals) {}
}
pub struct UnitHectopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectopascalsMul {
    #[inline]
    fn clone(&self) -> UnitHectopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitHectopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectopascalsMul> for i8 {
    type Output = Quantity<i8, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for i16 {
    type Output = Quantity<i16, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for i32 {
    type Output = Quantity<i32, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for i64 {
    type Output = Quantity<i64, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for i128 {
    type Output = Quantity<i128, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for isize {
    type Output = Quantity<isize, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for u8 {
    type Output = Quantity<u8, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for u16 {
    type Output = Quantity<u16, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for u32 {
    type Output = Quantity<u32, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for u64 {
    type Output = Quantity<u64, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for u128 {
    type Output = Quantity<u128, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for usize {
    type Output = Quantity<usize, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for f32 {
    type Output = Quantity<f32, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
impl Mul<UnitHectopascalsMul> for f64 {
    type Output = Quantity<f64, UnitHectopascals>;
    fn mul(self, _: UnitHectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitHectopascals)
    }
}
pub struct UnitDecapascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecapascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecapascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecapascals {
    #[inline]
    fn clone(&self) -> UnitDecapascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecapascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecapascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecapascals {
    #[inline]
    fn eq(&self, other: &UnitDecapascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecapascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecapascals {
    fn default() -> Self {
        UnitDecapascals
    }
}
impl Add<UnitDecapascals> for UnitDecapascals {
    type Output = UnitDecapascals;
    #[inline]
    fn add(self, _: UnitDecapascals) -> Self::Output {
        UnitDecapascals
    }
}
impl AddAssign<UnitDecapascals> for UnitDecapascals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecapascals) {}
}
impl Sub<UnitDecapascals> for UnitDecapascals {
    type Output = UnitDecapascals;
    #[inline]
    fn sub(self, _: UnitDecapascals) -> Self::Output {
        UnitDecapascals
    }
}
impl SubAssign<UnitDecapascals> for UnitDecapascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecapascals) {}
}
pub struct UnitDecapascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecapascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecapascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecapascalsMul {
    #[inline]
    fn clone(&self) -> UnitDecapascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecapascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecapascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecapascalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecapascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecapascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecapascalsMul> for i8 {
    type Output = Quantity<i8, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for i16 {
    type Output = Quantity<i16, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for i32 {
    type Output = Quantity<i32, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for i64 {
    type Output = Quantity<i64, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for i128 {
    type Output = Quantity<i128, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for isize {
    type Output = Quantity<isize, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for u8 {
    type Output = Quantity<u8, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for u16 {
    type Output = Quantity<u16, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for u32 {
    type Output = Quantity<u32, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for u64 {
    type Output = Quantity<u64, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for u128 {
    type Output = Quantity<u128, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for usize {
    type Output = Quantity<usize, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for f32 {
    type Output = Quantity<f32, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
impl Mul<UnitDecapascalsMul> for f64 {
    type Output = Quantity<f64, UnitDecapascals>;
    fn mul(self, _: UnitDecapascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecapascals)
    }
}
pub struct UnitDecipascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecipascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecipascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecipascals {
    #[inline]
    fn clone(&self) -> UnitDecipascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecipascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecipascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecipascals {
    #[inline]
    fn eq(&self, other: &UnitDecipascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecipascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecipascals {
    fn default() -> Self {
        UnitDecipascals
    }
}
impl Add<UnitDecipascals> for UnitDecipascals {
    type Output = UnitDecipascals;
    #[inline]
    fn add(self, _: UnitDecipascals) -> Self::Output {
        UnitDecipascals
    }
}
impl AddAssign<UnitDecipascals> for UnitDecipascals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecipascals) {}
}
impl Sub<UnitDecipascals> for UnitDecipascals {
    type Output = UnitDecipascals;
    #[inline]
    fn sub(self, _: UnitDecipascals) -> Self::Output {
        UnitDecipascals
    }
}
impl SubAssign<UnitDecipascals> for UnitDecipascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecipascals) {}
}
pub struct UnitDecipascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecipascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecipascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecipascalsMul {
    #[inline]
    fn clone(&self) -> UnitDecipascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecipascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecipascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecipascalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecipascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecipascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecipascalsMul> for i8 {
    type Output = Quantity<i8, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for i16 {
    type Output = Quantity<i16, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for i32 {
    type Output = Quantity<i32, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for i64 {
    type Output = Quantity<i64, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for i128 {
    type Output = Quantity<i128, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for isize {
    type Output = Quantity<isize, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for u8 {
    type Output = Quantity<u8, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for u16 {
    type Output = Quantity<u16, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for u32 {
    type Output = Quantity<u32, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for u64 {
    type Output = Quantity<u64, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for u128 {
    type Output = Quantity<u128, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for usize {
    type Output = Quantity<usize, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for f32 {
    type Output = Quantity<f32, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
impl Mul<UnitDecipascalsMul> for f64 {
    type Output = Quantity<f64, UnitDecipascals>;
    fn mul(self, _: UnitDecipascalsMul) -> Self::Output {
        Quantity::new(self, UnitDecipascals)
    }
}
pub struct UnitCentipascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentipascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentipascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentipascals {
    #[inline]
    fn clone(&self) -> UnitCentipascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentipascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentipascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentipascals {
    #[inline]
    fn eq(&self, other: &UnitCentipascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentipascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentipascals {
    fn default() -> Self {
        UnitCentipascals
    }
}
impl Add<UnitCentipascals> for UnitCentipascals {
    type Output = UnitCentipascals;
    #[inline]
    fn add(self, _: UnitCentipascals) -> Self::Output {
        UnitCentipascals
    }
}
impl AddAssign<UnitCentipascals> for UnitCentipascals {
    #[inline]
    fn add_assign(&mut self, _: UnitCentipascals) {}
}
impl Sub<UnitCentipascals> for UnitCentipascals {
    type Output = UnitCentipascals;
    #[inline]
    fn sub(self, _: UnitCentipascals) -> Self::Output {
        UnitCentipascals
    }
}
impl SubAssign<UnitCentipascals> for UnitCentipascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentipascals) {}
}
pub struct UnitCentipascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentipascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentipascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentipascalsMul {
    #[inline]
    fn clone(&self) -> UnitCentipascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentipascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentipascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentipascalsMul {
    #[inline]
    fn eq(&self, other: &UnitCentipascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentipascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentipascalsMul> for i8 {
    type Output = Quantity<i8, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for i16 {
    type Output = Quantity<i16, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for i32 {
    type Output = Quantity<i32, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for i64 {
    type Output = Quantity<i64, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for i128 {
    type Output = Quantity<i128, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for isize {
    type Output = Quantity<isize, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for u8 {
    type Output = Quantity<u8, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for u16 {
    type Output = Quantity<u16, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for u32 {
    type Output = Quantity<u32, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for u64 {
    type Output = Quantity<u64, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for u128 {
    type Output = Quantity<u128, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for usize {
    type Output = Quantity<usize, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for f32 {
    type Output = Quantity<f32, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
impl Mul<UnitCentipascalsMul> for f64 {
    type Output = Quantity<f64, UnitCentipascals>;
    fn mul(self, _: UnitCentipascalsMul) -> Self::Output {
        Quantity::new(self, UnitCentipascals)
    }
}
pub struct UnitMillipascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillipascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillipascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillipascals {
    #[inline]
    fn clone(&self) -> UnitMillipascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillipascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillipascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillipascals {
    #[inline]
    fn eq(&self, other: &UnitMillipascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillipascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillipascals {
    fn default() -> Self {
        UnitMillipascals
    }
}
impl Add<UnitMillipascals> for UnitMillipascals {
    type Output = UnitMillipascals;
    #[inline]
    fn add(self, _: UnitMillipascals) -> Self::Output {
        UnitMillipascals
    }
}
impl AddAssign<UnitMillipascals> for UnitMillipascals {
    #[inline]
    fn add_assign(&mut self, _: UnitMillipascals) {}
}
impl Sub<UnitMillipascals> for UnitMillipascals {
    type Output = UnitMillipascals;
    #[inline]
    fn sub(self, _: UnitMillipascals) -> Self::Output {
        UnitMillipascals
    }
}
impl SubAssign<UnitMillipascals> for UnitMillipascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillipascals) {}
}
pub struct UnitMillipascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillipascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillipascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillipascalsMul {
    #[inline]
    fn clone(&self) -> UnitMillipascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillipascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillipascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillipascalsMul {
    #[inline]
    fn eq(&self, other: &UnitMillipascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillipascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillipascalsMul> for i8 {
    type Output = Quantity<i8, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for i16 {
    type Output = Quantity<i16, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for i32 {
    type Output = Quantity<i32, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for i64 {
    type Output = Quantity<i64, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for i128 {
    type Output = Quantity<i128, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for isize {
    type Output = Quantity<isize, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for u8 {
    type Output = Quantity<u8, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for u16 {
    type Output = Quantity<u16, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for u32 {
    type Output = Quantity<u32, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for u64 {
    type Output = Quantity<u64, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for u128 {
    type Output = Quantity<u128, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for usize {
    type Output = Quantity<usize, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for f32 {
    type Output = Quantity<f32, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
impl Mul<UnitMillipascalsMul> for f64 {
    type Output = Quantity<f64, UnitMillipascals>;
    fn mul(self, _: UnitMillipascalsMul) -> Self::Output {
        Quantity::new(self, UnitMillipascals)
    }
}
pub struct UnitMicropascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicropascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicropascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicropascals {
    #[inline]
    fn clone(&self) -> UnitMicropascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicropascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicropascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicropascals {
    #[inline]
    fn eq(&self, other: &UnitMicropascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicropascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicropascals {
    fn default() -> Self {
        UnitMicropascals
    }
}
impl Add<UnitMicropascals> for UnitMicropascals {
    type Output = UnitMicropascals;
    #[inline]
    fn add(self, _: UnitMicropascals) -> Self::Output {
        UnitMicropascals
    }
}
impl AddAssign<UnitMicropascals> for UnitMicropascals {
    #[inline]
    fn add_assign(&mut self, _: UnitMicropascals) {}
}
impl Sub<UnitMicropascals> for UnitMicropascals {
    type Output = UnitMicropascals;
    #[inline]
    fn sub(self, _: UnitMicropascals) -> Self::Output {
        UnitMicropascals
    }
}
impl SubAssign<UnitMicropascals> for UnitMicropascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicropascals) {}
}
pub struct UnitMicropascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicropascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicropascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicropascalsMul {
    #[inline]
    fn clone(&self) -> UnitMicropascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicropascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicropascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicropascalsMul {
    #[inline]
    fn eq(&self, other: &UnitMicropascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicropascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicropascalsMul> for i8 {
    type Output = Quantity<i8, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for i16 {
    type Output = Quantity<i16, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for i32 {
    type Output = Quantity<i32, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for i64 {
    type Output = Quantity<i64, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for i128 {
    type Output = Quantity<i128, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for isize {
    type Output = Quantity<isize, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for u8 {
    type Output = Quantity<u8, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for u16 {
    type Output = Quantity<u16, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for u32 {
    type Output = Quantity<u32, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for u64 {
    type Output = Quantity<u64, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for u128 {
    type Output = Quantity<u128, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for usize {
    type Output = Quantity<usize, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for f32 {
    type Output = Quantity<f32, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
impl Mul<UnitMicropascalsMul> for f64 {
    type Output = Quantity<f64, UnitMicropascals>;
    fn mul(self, _: UnitMicropascalsMul) -> Self::Output {
        Quantity::new(self, UnitMicropascals)
    }
}
pub struct UnitNanopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanopascals {
    #[inline]
    fn clone(&self) -> UnitNanopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanopascals {
    #[inline]
    fn eq(&self, other: &UnitNanopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanopascals {
    fn default() -> Self {
        UnitNanopascals
    }
}
impl Add<UnitNanopascals> for UnitNanopascals {
    type Output = UnitNanopascals;
    #[inline]
    fn add(self, _: UnitNanopascals) -> Self::Output {
        UnitNanopascals
    }
}
impl AddAssign<UnitNanopascals> for UnitNanopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitNanopascals) {}
}
impl Sub<UnitNanopascals> for UnitNanopascals {
    type Output = UnitNanopascals;
    #[inline]
    fn sub(self, _: UnitNanopascals) -> Self::Output {
        UnitNanopascals
    }
}
impl SubAssign<UnitNanopascals> for UnitNanopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanopascals) {}
}
pub struct UnitNanopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanopascalsMul {
    #[inline]
    fn clone(&self) -> UnitNanopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitNanopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanopascalsMul> for i8 {
    type Output = Quantity<i8, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for i16 {
    type Output = Quantity<i16, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for i32 {
    type Output = Quantity<i32, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for i64 {
    type Output = Quantity<i64, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for i128 {
    type Output = Quantity<i128, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for isize {
    type Output = Quantity<isize, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for u8 {
    type Output = Quantity<u8, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for u16 {
    type Output = Quantity<u16, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for u32 {
    type Output = Quantity<u32, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for u64 {
    type Output = Quantity<u64, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for u128 {
    type Output = Quantity<u128, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for usize {
    type Output = Quantity<usize, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for f32 {
    type Output = Quantity<f32, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
impl Mul<UnitNanopascalsMul> for f64 {
    type Output = Quantity<f64, UnitNanopascals>;
    fn mul(self, _: UnitNanopascalsMul) -> Self::Output {
        Quantity::new(self, UnitNanopascals)
    }
}
pub struct UnitPicopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicopascals {
    #[inline]
    fn clone(&self) -> UnitPicopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicopascals {
    #[inline]
    fn eq(&self, other: &UnitPicopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicopascals {
    fn default() -> Self {
        UnitPicopascals
    }
}
impl Add<UnitPicopascals> for UnitPicopascals {
    type Output = UnitPicopascals;
    #[inline]
    fn add(self, _: UnitPicopascals) -> Self::Output {
        UnitPicopascals
    }
}
impl AddAssign<UnitPicopascals> for UnitPicopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitPicopascals) {}
}
impl Sub<UnitPicopascals> for UnitPicopascals {
    type Output = UnitPicopascals;
    #[inline]
    fn sub(self, _: UnitPicopascals) -> Self::Output {
        UnitPicopascals
    }
}
impl SubAssign<UnitPicopascals> for UnitPicopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicopascals) {}
}
pub struct UnitPicopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicopascalsMul {
    #[inline]
    fn clone(&self) -> UnitPicopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitPicopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicopascalsMul> for i8 {
    type Output = Quantity<i8, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for i16 {
    type Output = Quantity<i16, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for i32 {
    type Output = Quantity<i32, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for i64 {
    type Output = Quantity<i64, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for i128 {
    type Output = Quantity<i128, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for isize {
    type Output = Quantity<isize, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for u8 {
    type Output = Quantity<u8, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for u16 {
    type Output = Quantity<u16, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for u32 {
    type Output = Quantity<u32, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for u64 {
    type Output = Quantity<u64, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for u128 {
    type Output = Quantity<u128, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for usize {
    type Output = Quantity<usize, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for f32 {
    type Output = Quantity<f32, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
impl Mul<UnitPicopascalsMul> for f64 {
    type Output = Quantity<f64, UnitPicopascals>;
    fn mul(self, _: UnitPicopascalsMul) -> Self::Output {
        Quantity::new(self, UnitPicopascals)
    }
}
pub struct UnitFemtopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtopascals {
    #[inline]
    fn clone(&self) -> UnitFemtopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtopascals {
    #[inline]
    fn eq(&self, other: &UnitFemtopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtopascals {
    fn default() -> Self {
        UnitFemtopascals
    }
}
impl Add<UnitFemtopascals> for UnitFemtopascals {
    type Output = UnitFemtopascals;
    #[inline]
    fn add(self, _: UnitFemtopascals) -> Self::Output {
        UnitFemtopascals
    }
}
impl AddAssign<UnitFemtopascals> for UnitFemtopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtopascals) {}
}
impl Sub<UnitFemtopascals> for UnitFemtopascals {
    type Output = UnitFemtopascals;
    #[inline]
    fn sub(self, _: UnitFemtopascals) -> Self::Output {
        UnitFemtopascals
    }
}
impl SubAssign<UnitFemtopascals> for UnitFemtopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtopascals) {}
}
pub struct UnitFemtopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtopascalsMul {
    #[inline]
    fn clone(&self) -> UnitFemtopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtopascalsMul> for i8 {
    type Output = Quantity<i8, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for i16 {
    type Output = Quantity<i16, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for i32 {
    type Output = Quantity<i32, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for i64 {
    type Output = Quantity<i64, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for i128 {
    type Output = Quantity<i128, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for isize {
    type Output = Quantity<isize, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for u8 {
    type Output = Quantity<u8, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for u16 {
    type Output = Quantity<u16, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for u32 {
    type Output = Quantity<u32, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for u64 {
    type Output = Quantity<u64, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for u128 {
    type Output = Quantity<u128, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for usize {
    type Output = Quantity<usize, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for f32 {
    type Output = Quantity<f32, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
impl Mul<UnitFemtopascalsMul> for f64 {
    type Output = Quantity<f64, UnitFemtopascals>;
    fn mul(self, _: UnitFemtopascalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtopascals)
    }
}
pub struct UnitAttopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttopascals {
    #[inline]
    fn clone(&self) -> UnitAttopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttopascals {
    #[inline]
    fn eq(&self, other: &UnitAttopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttopascals {
    fn default() -> Self {
        UnitAttopascals
    }
}
impl Add<UnitAttopascals> for UnitAttopascals {
    type Output = UnitAttopascals;
    #[inline]
    fn add(self, _: UnitAttopascals) -> Self::Output {
        UnitAttopascals
    }
}
impl AddAssign<UnitAttopascals> for UnitAttopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitAttopascals) {}
}
impl Sub<UnitAttopascals> for UnitAttopascals {
    type Output = UnitAttopascals;
    #[inline]
    fn sub(self, _: UnitAttopascals) -> Self::Output {
        UnitAttopascals
    }
}
impl SubAssign<UnitAttopascals> for UnitAttopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttopascals) {}
}
pub struct UnitAttopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttopascalsMul {
    #[inline]
    fn clone(&self) -> UnitAttopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitAttopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttopascalsMul> for i8 {
    type Output = Quantity<i8, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for i16 {
    type Output = Quantity<i16, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for i32 {
    type Output = Quantity<i32, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for i64 {
    type Output = Quantity<i64, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for i128 {
    type Output = Quantity<i128, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for isize {
    type Output = Quantity<isize, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for u8 {
    type Output = Quantity<u8, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for u16 {
    type Output = Quantity<u16, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for u32 {
    type Output = Quantity<u32, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for u64 {
    type Output = Quantity<u64, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for u128 {
    type Output = Quantity<u128, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for usize {
    type Output = Quantity<usize, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for f32 {
    type Output = Quantity<f32, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
impl Mul<UnitAttopascalsMul> for f64 {
    type Output = Quantity<f64, UnitAttopascals>;
    fn mul(self, _: UnitAttopascalsMul) -> Self::Output {
        Quantity::new(self, UnitAttopascals)
    }
}
pub struct UnitZeptopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptopascals {
    #[inline]
    fn clone(&self) -> UnitZeptopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptopascals {
    #[inline]
    fn eq(&self, other: &UnitZeptopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptopascals {
    fn default() -> Self {
        UnitZeptopascals
    }
}
impl Add<UnitZeptopascals> for UnitZeptopascals {
    type Output = UnitZeptopascals;
    #[inline]
    fn add(self, _: UnitZeptopascals) -> Self::Output {
        UnitZeptopascals
    }
}
impl AddAssign<UnitZeptopascals> for UnitZeptopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptopascals) {}
}
impl Sub<UnitZeptopascals> for UnitZeptopascals {
    type Output = UnitZeptopascals;
    #[inline]
    fn sub(self, _: UnitZeptopascals) -> Self::Output {
        UnitZeptopascals
    }
}
impl SubAssign<UnitZeptopascals> for UnitZeptopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptopascals) {}
}
pub struct UnitZeptopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptopascalsMul {
    #[inline]
    fn clone(&self) -> UnitZeptopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptopascalsMul> for i8 {
    type Output = Quantity<i8, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for i16 {
    type Output = Quantity<i16, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for i32 {
    type Output = Quantity<i32, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for i64 {
    type Output = Quantity<i64, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for i128 {
    type Output = Quantity<i128, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for isize {
    type Output = Quantity<isize, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for u8 {
    type Output = Quantity<u8, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for u16 {
    type Output = Quantity<u16, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for u32 {
    type Output = Quantity<u32, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for u64 {
    type Output = Quantity<u64, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for u128 {
    type Output = Quantity<u128, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for usize {
    type Output = Quantity<usize, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for f32 {
    type Output = Quantity<f32, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
impl Mul<UnitZeptopascalsMul> for f64 {
    type Output = Quantity<f64, UnitZeptopascals>;
    fn mul(self, _: UnitZeptopascalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptopascals)
    }
}
pub struct UnitYoctopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctopascals {
    #[inline]
    fn clone(&self) -> UnitYoctopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctopascals {
    #[inline]
    fn eq(&self, other: &UnitYoctopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctopascals {
    fn default() -> Self {
        UnitYoctopascals
    }
}
impl Add<UnitYoctopascals> for UnitYoctopascals {
    type Output = UnitYoctopascals;
    #[inline]
    fn add(self, _: UnitYoctopascals) -> Self::Output {
        UnitYoctopascals
    }
}
impl AddAssign<UnitYoctopascals> for UnitYoctopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctopascals) {}
}
impl Sub<UnitYoctopascals> for UnitYoctopascals {
    type Output = UnitYoctopascals;
    #[inline]
    fn sub(self, _: UnitYoctopascals) -> Self::Output {
        UnitYoctopascals
    }
}
impl SubAssign<UnitYoctopascals> for UnitYoctopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctopascals) {}
}
pub struct UnitYoctopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctopascalsMul {
    #[inline]
    fn clone(&self) -> UnitYoctopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctopascalsMul> for i8 {
    type Output = Quantity<i8, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for i16 {
    type Output = Quantity<i16, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for i32 {
    type Output = Quantity<i32, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for i64 {
    type Output = Quantity<i64, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for i128 {
    type Output = Quantity<i128, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for isize {
    type Output = Quantity<isize, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for u8 {
    type Output = Quantity<u8, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for u16 {
    type Output = Quantity<u16, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for u32 {
    type Output = Quantity<u32, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for u64 {
    type Output = Quantity<u64, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for u128 {
    type Output = Quantity<u128, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for usize {
    type Output = Quantity<usize, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for f32 {
    type Output = Quantity<f32, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
impl Mul<UnitYoctopascalsMul> for f64 {
    type Output = Quantity<f64, UnitYoctopascals>;
    fn mul(self, _: UnitYoctopascalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctopascals)
    }
}
pub struct UnitRontopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontopascals {
    #[inline]
    fn clone(&self) -> UnitRontopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontopascals {
    #[inline]
    fn eq(&self, other: &UnitRontopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontopascals {
    fn default() -> Self {
        UnitRontopascals
    }
}
impl Add<UnitRontopascals> for UnitRontopascals {
    type Output = UnitRontopascals;
    #[inline]
    fn add(self, _: UnitRontopascals) -> Self::Output {
        UnitRontopascals
    }
}
impl AddAssign<UnitRontopascals> for UnitRontopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitRontopascals) {}
}
impl Sub<UnitRontopascals> for UnitRontopascals {
    type Output = UnitRontopascals;
    #[inline]
    fn sub(self, _: UnitRontopascals) -> Self::Output {
        UnitRontopascals
    }
}
impl SubAssign<UnitRontopascals> for UnitRontopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontopascals) {}
}
pub struct UnitRontopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontopascalsMul {
    #[inline]
    fn clone(&self) -> UnitRontopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitRontopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontopascalsMul> for i8 {
    type Output = Quantity<i8, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for i16 {
    type Output = Quantity<i16, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for i32 {
    type Output = Quantity<i32, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for i64 {
    type Output = Quantity<i64, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for i128 {
    type Output = Quantity<i128, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for isize {
    type Output = Quantity<isize, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for u8 {
    type Output = Quantity<u8, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for u16 {
    type Output = Quantity<u16, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for u32 {
    type Output = Quantity<u32, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for u64 {
    type Output = Quantity<u64, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for u128 {
    type Output = Quantity<u128, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for usize {
    type Output = Quantity<usize, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for f32 {
    type Output = Quantity<f32, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
impl Mul<UnitRontopascalsMul> for f64 {
    type Output = Quantity<f64, UnitRontopascals>;
    fn mul(self, _: UnitRontopascalsMul) -> Self::Output {
        Quantity::new(self, UnitRontopascals)
    }
}
pub struct UnitQuectopascals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectopascals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectopascals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectopascals {
    #[inline]
    fn clone(&self) -> UnitQuectopascals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectopascals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectopascals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectopascals {
    #[inline]
    fn eq(&self, other: &UnitQuectopascals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectopascals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectopascals {
    fn default() -> Self {
        UnitQuectopascals
    }
}
impl Add<UnitQuectopascals> for UnitQuectopascals {
    type Output = UnitQuectopascals;
    #[inline]
    fn add(self, _: UnitQuectopascals) -> Self::Output {
        UnitQuectopascals
    }
}
impl AddAssign<UnitQuectopascals> for UnitQuectopascals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectopascals) {}
}
impl Sub<UnitQuectopascals> for UnitQuectopascals {
    type Output = UnitQuectopascals;
    #[inline]
    fn sub(self, _: UnitQuectopascals) -> Self::Output {
        UnitQuectopascals
    }
}
impl SubAssign<UnitQuectopascals> for UnitQuectopascals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectopascals) {}
}
pub struct UnitQuectopascalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectopascalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectopascalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectopascalsMul {
    #[inline]
    fn clone(&self) -> UnitQuectopascalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectopascalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectopascalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectopascalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectopascalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectopascalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectopascalsMul> for i8 {
    type Output = Quantity<i8, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for i16 {
    type Output = Quantity<i16, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for i32 {
    type Output = Quantity<i32, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for i64 {
    type Output = Quantity<i64, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for i128 {
    type Output = Quantity<i128, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for isize {
    type Output = Quantity<isize, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for u8 {
    type Output = Quantity<u8, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for u16 {
    type Output = Quantity<u16, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for u32 {
    type Output = Quantity<u32, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for u64 {
    type Output = Quantity<u64, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for u128 {
    type Output = Quantity<u128, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for usize {
    type Output = Quantity<usize, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for f32 {
    type Output = Quantity<f32, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
impl Mul<UnitQuectopascalsMul> for f64 {
    type Output = Quantity<f64, UnitQuectopascals>;
    fn mul(self, _: UnitQuectopascalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectopascals)
    }
}
pub type Pascals<T> = Quantity<T, UnitPascals>;
#[allow(non_upper_case_globals)]
pub static Pascals: UnitPascalsMul = UnitPascalsMul;
pub type Quettapascals<T> = Quantity<T, UnitQuettapascals>;
#[allow(non_upper_case_globals)]
pub static Quettapascals: UnitQuettapascalsMul = UnitQuettapascalsMul;
pub type Ronnapascals<T> = Quantity<T, UnitRonnapascals>;
#[allow(non_upper_case_globals)]
pub static Ronnapascals: UnitRonnapascalsMul = UnitRonnapascalsMul;
pub type Yottapascals<T> = Quantity<T, UnitYottapascals>;
#[allow(non_upper_case_globals)]
pub static Yottapascals: UnitYottapascalsMul = UnitYottapascalsMul;
pub type Zettapascals<T> = Quantity<T, UnitZettapascals>;
#[allow(non_upper_case_globals)]
pub static Zettapascals: UnitZettapascalsMul = UnitZettapascalsMul;
pub type Exapascals<T> = Quantity<T, UnitExapascals>;
#[allow(non_upper_case_globals)]
pub static Exapascals: UnitExapascalsMul = UnitExapascalsMul;
pub type Petapascals<T> = Quantity<T, UnitPetapascals>;
#[allow(non_upper_case_globals)]
pub static Petapascals: UnitPetapascalsMul = UnitPetapascalsMul;
pub type Terapascals<T> = Quantity<T, UnitTerapascals>;
#[allow(non_upper_case_globals)]
pub static Terapascals: UnitTerapascalsMul = UnitTerapascalsMul;
pub type Gigapascals<T> = Quantity<T, UnitGigapascals>;
#[allow(non_upper_case_globals)]
pub static Gigapascals: UnitGigapascalsMul = UnitGigapascalsMul;
pub type Megapascals<T> = Quantity<T, UnitMegapascals>;
#[allow(non_upper_case_globals)]
pub static Megapascals: UnitMegapascalsMul = UnitMegapascalsMul;
pub type Kilopascals<T> = Quantity<T, UnitKilopascals>;
#[allow(non_upper_case_globals)]
pub static Kilopascals: UnitKilopascalsMul = UnitKilopascalsMul;
pub type Hectopascals<T> = Quantity<T, UnitHectopascals>;
#[allow(non_upper_case_globals)]
pub static Hectopascals: UnitHectopascalsMul = UnitHectopascalsMul;
pub type Decapascals<T> = Quantity<T, UnitDecapascals>;
#[allow(non_upper_case_globals)]
pub static Decapascals: UnitDecapascalsMul = UnitDecapascalsMul;
pub type Decipascals<T> = Quantity<T, UnitDecipascals>;
#[allow(non_upper_case_globals)]
pub static Decipascals: UnitDecipascalsMul = UnitDecipascalsMul;
pub type Centipascals<T> = Quantity<T, UnitCentipascals>;
#[allow(non_upper_case_globals)]
pub static Centipascals: UnitCentipascalsMul = UnitCentipascalsMul;
pub type Millipascals<T> = Quantity<T, UnitMillipascals>;
#[allow(non_upper_case_globals)]
pub static Millipascals: UnitMillipascalsMul = UnitMillipascalsMul;
pub type Micropascals<T> = Quantity<T, UnitMicropascals>;
#[allow(non_upper_case_globals)]
pub static Micropascals: UnitMicropascalsMul = UnitMicropascalsMul;
pub type Nanopascals<T> = Quantity<T, UnitNanopascals>;
#[allow(non_upper_case_globals)]
pub static Nanopascals: UnitNanopascalsMul = UnitNanopascalsMul;
pub type Picopascals<T> = Quantity<T, UnitPicopascals>;
#[allow(non_upper_case_globals)]
pub static Picopascals: UnitPicopascalsMul = UnitPicopascalsMul;
pub type Femtopascals<T> = Quantity<T, UnitFemtopascals>;
#[allow(non_upper_case_globals)]
pub static Femtopascals: UnitFemtopascalsMul = UnitFemtopascalsMul;
pub type Attopascals<T> = Quantity<T, UnitAttopascals>;
#[allow(non_upper_case_globals)]
pub static Attopascals: UnitAttopascalsMul = UnitAttopascalsMul;
pub type Zeptopascals<T> = Quantity<T, UnitZeptopascals>;
#[allow(non_upper_case_globals)]
pub static Zeptopascals: UnitZeptopascalsMul = UnitZeptopascalsMul;
pub type Yoctopascals<T> = Quantity<T, UnitYoctopascals>;
#[allow(non_upper_case_globals)]
pub static Yoctopascals: UnitYoctopascalsMul = UnitYoctopascalsMul;
pub type Rontopascals<T> = Quantity<T, UnitRontopascals>;
#[allow(non_upper_case_globals)]
pub static Rontopascals: UnitRontopascalsMul = UnitRontopascalsMul;
pub type Quectopascals<T> = Quantity<T, UnitQuectopascals>;
#[allow(non_upper_case_globals)]
pub static Quectopascals: UnitQuectopascalsMul = UnitQuectopascalsMul;
pub struct UnitJoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitJoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitJoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitJoules {
    #[inline]
    fn clone(&self) -> UnitJoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitJoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitJoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitJoules {
    #[inline]
    fn eq(&self, other: &UnitJoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitJoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitJoules {
    fn default() -> Self {
        UnitJoules
    }
}
impl Add<UnitJoules> for UnitJoules {
    type Output = UnitJoules;
    #[inline]
    fn add(self, _: UnitJoules) -> Self::Output {
        UnitJoules
    }
}
impl AddAssign<UnitJoules> for UnitJoules {
    #[inline]
    fn add_assign(&mut self, _: UnitJoules) {}
}
impl Sub<UnitJoules> for UnitJoules {
    type Output = UnitJoules;
    #[inline]
    fn sub(self, _: UnitJoules) -> Self::Output {
        UnitJoules
    }
}
impl SubAssign<UnitJoules> for UnitJoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitJoules) {}
}
pub struct UnitJoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitJoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitJoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitJoulesMul {
    #[inline]
    fn clone(&self) -> UnitJoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitJoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitJoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitJoulesMul {
    #[inline]
    fn eq(&self, other: &UnitJoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitJoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitJoulesMul> for i8 {
    type Output = Quantity<i8, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for i16 {
    type Output = Quantity<i16, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for i32 {
    type Output = Quantity<i32, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for i64 {
    type Output = Quantity<i64, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for i128 {
    type Output = Quantity<i128, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for isize {
    type Output = Quantity<isize, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for u8 {
    type Output = Quantity<u8, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for u16 {
    type Output = Quantity<u16, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for u32 {
    type Output = Quantity<u32, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for u64 {
    type Output = Quantity<u64, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for u128 {
    type Output = Quantity<u128, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for usize {
    type Output = Quantity<usize, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for f32 {
    type Output = Quantity<f32, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
impl Mul<UnitJoulesMul> for f64 {
    type Output = Quantity<f64, UnitJoules>;
    fn mul(self, _: UnitJoulesMul) -> Self::Output {
        Quantity::new(self, UnitJoules)
    }
}
pub struct UnitQuettajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettajoules {
    #[inline]
    fn clone(&self) -> UnitQuettajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettajoules {
    #[inline]
    fn eq(&self, other: &UnitQuettajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettajoules {
    fn default() -> Self {
        UnitQuettajoules
    }
}
impl Add<UnitQuettajoules> for UnitQuettajoules {
    type Output = UnitQuettajoules;
    #[inline]
    fn add(self, _: UnitQuettajoules) -> Self::Output {
        UnitQuettajoules
    }
}
impl AddAssign<UnitQuettajoules> for UnitQuettajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettajoules) {}
}
impl Sub<UnitQuettajoules> for UnitQuettajoules {
    type Output = UnitQuettajoules;
    #[inline]
    fn sub(self, _: UnitQuettajoules) -> Self::Output {
        UnitQuettajoules
    }
}
impl SubAssign<UnitQuettajoules> for UnitQuettajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettajoules) {}
}
pub struct UnitQuettajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettajoulesMul {
    #[inline]
    fn clone(&self) -> UnitQuettajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettajoulesMul> for i8 {
    type Output = Quantity<i8, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for i16 {
    type Output = Quantity<i16, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for i32 {
    type Output = Quantity<i32, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for i64 {
    type Output = Quantity<i64, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for i128 {
    type Output = Quantity<i128, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for isize {
    type Output = Quantity<isize, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for u8 {
    type Output = Quantity<u8, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for u16 {
    type Output = Quantity<u16, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for u32 {
    type Output = Quantity<u32, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for u64 {
    type Output = Quantity<u64, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for u128 {
    type Output = Quantity<u128, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for usize {
    type Output = Quantity<usize, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for f32 {
    type Output = Quantity<f32, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
impl Mul<UnitQuettajoulesMul> for f64 {
    type Output = Quantity<f64, UnitQuettajoules>;
    fn mul(self, _: UnitQuettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuettajoules)
    }
}
pub struct UnitRonnajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnajoules {
    #[inline]
    fn clone(&self) -> UnitRonnajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnajoules {
    #[inline]
    fn eq(&self, other: &UnitRonnajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnajoules {
    fn default() -> Self {
        UnitRonnajoules
    }
}
impl Add<UnitRonnajoules> for UnitRonnajoules {
    type Output = UnitRonnajoules;
    #[inline]
    fn add(self, _: UnitRonnajoules) -> Self::Output {
        UnitRonnajoules
    }
}
impl AddAssign<UnitRonnajoules> for UnitRonnajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnajoules) {}
}
impl Sub<UnitRonnajoules> for UnitRonnajoules {
    type Output = UnitRonnajoules;
    #[inline]
    fn sub(self, _: UnitRonnajoules) -> Self::Output {
        UnitRonnajoules
    }
}
impl SubAssign<UnitRonnajoules> for UnitRonnajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnajoules) {}
}
pub struct UnitRonnajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnajoulesMul {
    #[inline]
    fn clone(&self) -> UnitRonnajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnajoulesMul> for i8 {
    type Output = Quantity<i8, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for i16 {
    type Output = Quantity<i16, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for i32 {
    type Output = Quantity<i32, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for i64 {
    type Output = Quantity<i64, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for i128 {
    type Output = Quantity<i128, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for isize {
    type Output = Quantity<isize, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for u8 {
    type Output = Quantity<u8, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for u16 {
    type Output = Quantity<u16, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for u32 {
    type Output = Quantity<u32, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for u64 {
    type Output = Quantity<u64, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for u128 {
    type Output = Quantity<u128, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for usize {
    type Output = Quantity<usize, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for f32 {
    type Output = Quantity<f32, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
impl Mul<UnitRonnajoulesMul> for f64 {
    type Output = Quantity<f64, UnitRonnajoules>;
    fn mul(self, _: UnitRonnajoulesMul) -> Self::Output {
        Quantity::new(self, UnitRonnajoules)
    }
}
pub struct UnitYottajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottajoules {
    #[inline]
    fn clone(&self) -> UnitYottajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottajoules {
    #[inline]
    fn eq(&self, other: &UnitYottajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottajoules {
    fn default() -> Self {
        UnitYottajoules
    }
}
impl Add<UnitYottajoules> for UnitYottajoules {
    type Output = UnitYottajoules;
    #[inline]
    fn add(self, _: UnitYottajoules) -> Self::Output {
        UnitYottajoules
    }
}
impl AddAssign<UnitYottajoules> for UnitYottajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitYottajoules) {}
}
impl Sub<UnitYottajoules> for UnitYottajoules {
    type Output = UnitYottajoules;
    #[inline]
    fn sub(self, _: UnitYottajoules) -> Self::Output {
        UnitYottajoules
    }
}
impl SubAssign<UnitYottajoules> for UnitYottajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottajoules) {}
}
pub struct UnitYottajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottajoulesMul {
    #[inline]
    fn clone(&self) -> UnitYottajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitYottajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottajoulesMul> for i8 {
    type Output = Quantity<i8, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for i16 {
    type Output = Quantity<i16, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for i32 {
    type Output = Quantity<i32, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for i64 {
    type Output = Quantity<i64, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for i128 {
    type Output = Quantity<i128, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for isize {
    type Output = Quantity<isize, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for u8 {
    type Output = Quantity<u8, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for u16 {
    type Output = Quantity<u16, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for u32 {
    type Output = Quantity<u32, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for u64 {
    type Output = Quantity<u64, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for u128 {
    type Output = Quantity<u128, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for usize {
    type Output = Quantity<usize, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for f32 {
    type Output = Quantity<f32, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
impl Mul<UnitYottajoulesMul> for f64 {
    type Output = Quantity<f64, UnitYottajoules>;
    fn mul(self, _: UnitYottajoulesMul) -> Self::Output {
        Quantity::new(self, UnitYottajoules)
    }
}
pub struct UnitZettajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettajoules {
    #[inline]
    fn clone(&self) -> UnitZettajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettajoules {
    #[inline]
    fn eq(&self, other: &UnitZettajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettajoules {
    fn default() -> Self {
        UnitZettajoules
    }
}
impl Add<UnitZettajoules> for UnitZettajoules {
    type Output = UnitZettajoules;
    #[inline]
    fn add(self, _: UnitZettajoules) -> Self::Output {
        UnitZettajoules
    }
}
impl AddAssign<UnitZettajoules> for UnitZettajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitZettajoules) {}
}
impl Sub<UnitZettajoules> for UnitZettajoules {
    type Output = UnitZettajoules;
    #[inline]
    fn sub(self, _: UnitZettajoules) -> Self::Output {
        UnitZettajoules
    }
}
impl SubAssign<UnitZettajoules> for UnitZettajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettajoules) {}
}
pub struct UnitZettajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettajoulesMul {
    #[inline]
    fn clone(&self) -> UnitZettajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitZettajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettajoulesMul> for i8 {
    type Output = Quantity<i8, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for i16 {
    type Output = Quantity<i16, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for i32 {
    type Output = Quantity<i32, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for i64 {
    type Output = Quantity<i64, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for i128 {
    type Output = Quantity<i128, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for isize {
    type Output = Quantity<isize, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for u8 {
    type Output = Quantity<u8, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for u16 {
    type Output = Quantity<u16, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for u32 {
    type Output = Quantity<u32, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for u64 {
    type Output = Quantity<u64, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for u128 {
    type Output = Quantity<u128, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for usize {
    type Output = Quantity<usize, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for f32 {
    type Output = Quantity<f32, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
impl Mul<UnitZettajoulesMul> for f64 {
    type Output = Quantity<f64, UnitZettajoules>;
    fn mul(self, _: UnitZettajoulesMul) -> Self::Output {
        Quantity::new(self, UnitZettajoules)
    }
}
pub struct UnitExajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExajoules {
    #[inline]
    fn clone(&self) -> UnitExajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExajoules {
    #[inline]
    fn eq(&self, other: &UnitExajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExajoules {
    fn default() -> Self {
        UnitExajoules
    }
}
impl Add<UnitExajoules> for UnitExajoules {
    type Output = UnitExajoules;
    #[inline]
    fn add(self, _: UnitExajoules) -> Self::Output {
        UnitExajoules
    }
}
impl AddAssign<UnitExajoules> for UnitExajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitExajoules) {}
}
impl Sub<UnitExajoules> for UnitExajoules {
    type Output = UnitExajoules;
    #[inline]
    fn sub(self, _: UnitExajoules) -> Self::Output {
        UnitExajoules
    }
}
impl SubAssign<UnitExajoules> for UnitExajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitExajoules) {}
}
pub struct UnitExajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExajoulesMul {
    #[inline]
    fn clone(&self) -> UnitExajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitExajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExajoulesMul> for i8 {
    type Output = Quantity<i8, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for i16 {
    type Output = Quantity<i16, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for i32 {
    type Output = Quantity<i32, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for i64 {
    type Output = Quantity<i64, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for i128 {
    type Output = Quantity<i128, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for isize {
    type Output = Quantity<isize, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for u8 {
    type Output = Quantity<u8, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for u16 {
    type Output = Quantity<u16, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for u32 {
    type Output = Quantity<u32, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for u64 {
    type Output = Quantity<u64, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for u128 {
    type Output = Quantity<u128, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for usize {
    type Output = Quantity<usize, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for f32 {
    type Output = Quantity<f32, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
impl Mul<UnitExajoulesMul> for f64 {
    type Output = Quantity<f64, UnitExajoules>;
    fn mul(self, _: UnitExajoulesMul) -> Self::Output {
        Quantity::new(self, UnitExajoules)
    }
}
pub struct UnitPetajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetajoules {
    #[inline]
    fn clone(&self) -> UnitPetajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetajoules {
    #[inline]
    fn eq(&self, other: &UnitPetajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetajoules {
    fn default() -> Self {
        UnitPetajoules
    }
}
impl Add<UnitPetajoules> for UnitPetajoules {
    type Output = UnitPetajoules;
    #[inline]
    fn add(self, _: UnitPetajoules) -> Self::Output {
        UnitPetajoules
    }
}
impl AddAssign<UnitPetajoules> for UnitPetajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitPetajoules) {}
}
impl Sub<UnitPetajoules> for UnitPetajoules {
    type Output = UnitPetajoules;
    #[inline]
    fn sub(self, _: UnitPetajoules) -> Self::Output {
        UnitPetajoules
    }
}
impl SubAssign<UnitPetajoules> for UnitPetajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetajoules) {}
}
pub struct UnitPetajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetajoulesMul {
    #[inline]
    fn clone(&self) -> UnitPetajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitPetajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetajoulesMul> for i8 {
    type Output = Quantity<i8, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for i16 {
    type Output = Quantity<i16, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for i32 {
    type Output = Quantity<i32, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for i64 {
    type Output = Quantity<i64, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for i128 {
    type Output = Quantity<i128, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for isize {
    type Output = Quantity<isize, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for u8 {
    type Output = Quantity<u8, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for u16 {
    type Output = Quantity<u16, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for u32 {
    type Output = Quantity<u32, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for u64 {
    type Output = Quantity<u64, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for u128 {
    type Output = Quantity<u128, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for usize {
    type Output = Quantity<usize, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for f32 {
    type Output = Quantity<f32, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
impl Mul<UnitPetajoulesMul> for f64 {
    type Output = Quantity<f64, UnitPetajoules>;
    fn mul(self, _: UnitPetajoulesMul) -> Self::Output {
        Quantity::new(self, UnitPetajoules)
    }
}
pub struct UnitTerajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerajoules {
    #[inline]
    fn clone(&self) -> UnitTerajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerajoules {
    #[inline]
    fn eq(&self, other: &UnitTerajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerajoules {
    fn default() -> Self {
        UnitTerajoules
    }
}
impl Add<UnitTerajoules> for UnitTerajoules {
    type Output = UnitTerajoules;
    #[inline]
    fn add(self, _: UnitTerajoules) -> Self::Output {
        UnitTerajoules
    }
}
impl AddAssign<UnitTerajoules> for UnitTerajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitTerajoules) {}
}
impl Sub<UnitTerajoules> for UnitTerajoules {
    type Output = UnitTerajoules;
    #[inline]
    fn sub(self, _: UnitTerajoules) -> Self::Output {
        UnitTerajoules
    }
}
impl SubAssign<UnitTerajoules> for UnitTerajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerajoules) {}
}
pub struct UnitTerajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerajoulesMul {
    #[inline]
    fn clone(&self) -> UnitTerajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitTerajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerajoulesMul> for i8 {
    type Output = Quantity<i8, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for i16 {
    type Output = Quantity<i16, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for i32 {
    type Output = Quantity<i32, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for i64 {
    type Output = Quantity<i64, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for i128 {
    type Output = Quantity<i128, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for isize {
    type Output = Quantity<isize, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for u8 {
    type Output = Quantity<u8, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for u16 {
    type Output = Quantity<u16, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for u32 {
    type Output = Quantity<u32, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for u64 {
    type Output = Quantity<u64, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for u128 {
    type Output = Quantity<u128, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for usize {
    type Output = Quantity<usize, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for f32 {
    type Output = Quantity<f32, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
impl Mul<UnitTerajoulesMul> for f64 {
    type Output = Quantity<f64, UnitTerajoules>;
    fn mul(self, _: UnitTerajoulesMul) -> Self::Output {
        Quantity::new(self, UnitTerajoules)
    }
}
pub struct UnitGigajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigajoules {
    #[inline]
    fn clone(&self) -> UnitGigajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigajoules {
    #[inline]
    fn eq(&self, other: &UnitGigajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigajoules {
    fn default() -> Self {
        UnitGigajoules
    }
}
impl Add<UnitGigajoules> for UnitGigajoules {
    type Output = UnitGigajoules;
    #[inline]
    fn add(self, _: UnitGigajoules) -> Self::Output {
        UnitGigajoules
    }
}
impl AddAssign<UnitGigajoules> for UnitGigajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitGigajoules) {}
}
impl Sub<UnitGigajoules> for UnitGigajoules {
    type Output = UnitGigajoules;
    #[inline]
    fn sub(self, _: UnitGigajoules) -> Self::Output {
        UnitGigajoules
    }
}
impl SubAssign<UnitGigajoules> for UnitGigajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigajoules) {}
}
pub struct UnitGigajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigajoulesMul {
    #[inline]
    fn clone(&self) -> UnitGigajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitGigajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigajoulesMul> for i8 {
    type Output = Quantity<i8, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for i16 {
    type Output = Quantity<i16, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for i32 {
    type Output = Quantity<i32, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for i64 {
    type Output = Quantity<i64, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for i128 {
    type Output = Quantity<i128, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for isize {
    type Output = Quantity<isize, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for u8 {
    type Output = Quantity<u8, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for u16 {
    type Output = Quantity<u16, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for u32 {
    type Output = Quantity<u32, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for u64 {
    type Output = Quantity<u64, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for u128 {
    type Output = Quantity<u128, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for usize {
    type Output = Quantity<usize, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for f32 {
    type Output = Quantity<f32, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
impl Mul<UnitGigajoulesMul> for f64 {
    type Output = Quantity<f64, UnitGigajoules>;
    fn mul(self, _: UnitGigajoulesMul) -> Self::Output {
        Quantity::new(self, UnitGigajoules)
    }
}
pub struct UnitMegajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegajoules {
    #[inline]
    fn clone(&self) -> UnitMegajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegajoules {
    #[inline]
    fn eq(&self, other: &UnitMegajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegajoules {
    fn default() -> Self {
        UnitMegajoules
    }
}
impl Add<UnitMegajoules> for UnitMegajoules {
    type Output = UnitMegajoules;
    #[inline]
    fn add(self, _: UnitMegajoules) -> Self::Output {
        UnitMegajoules
    }
}
impl AddAssign<UnitMegajoules> for UnitMegajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitMegajoules) {}
}
impl Sub<UnitMegajoules> for UnitMegajoules {
    type Output = UnitMegajoules;
    #[inline]
    fn sub(self, _: UnitMegajoules) -> Self::Output {
        UnitMegajoules
    }
}
impl SubAssign<UnitMegajoules> for UnitMegajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegajoules) {}
}
pub struct UnitMegajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegajoulesMul {
    #[inline]
    fn clone(&self) -> UnitMegajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitMegajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegajoulesMul> for i8 {
    type Output = Quantity<i8, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for i16 {
    type Output = Quantity<i16, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for i32 {
    type Output = Quantity<i32, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for i64 {
    type Output = Quantity<i64, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for i128 {
    type Output = Quantity<i128, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for isize {
    type Output = Quantity<isize, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for u8 {
    type Output = Quantity<u8, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for u16 {
    type Output = Quantity<u16, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for u32 {
    type Output = Quantity<u32, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for u64 {
    type Output = Quantity<u64, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for u128 {
    type Output = Quantity<u128, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for usize {
    type Output = Quantity<usize, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for f32 {
    type Output = Quantity<f32, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
impl Mul<UnitMegajoulesMul> for f64 {
    type Output = Quantity<f64, UnitMegajoules>;
    fn mul(self, _: UnitMegajoulesMul) -> Self::Output {
        Quantity::new(self, UnitMegajoules)
    }
}
pub struct UnitKilojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilojoules {
    #[inline]
    fn clone(&self) -> UnitKilojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilojoules {
    #[inline]
    fn eq(&self, other: &UnitKilojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilojoules {
    fn default() -> Self {
        UnitKilojoules
    }
}
impl Add<UnitKilojoules> for UnitKilojoules {
    type Output = UnitKilojoules;
    #[inline]
    fn add(self, _: UnitKilojoules) -> Self::Output {
        UnitKilojoules
    }
}
impl AddAssign<UnitKilojoules> for UnitKilojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitKilojoules) {}
}
impl Sub<UnitKilojoules> for UnitKilojoules {
    type Output = UnitKilojoules;
    #[inline]
    fn sub(self, _: UnitKilojoules) -> Self::Output {
        UnitKilojoules
    }
}
impl SubAssign<UnitKilojoules> for UnitKilojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilojoules) {}
}
pub struct UnitKilojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilojoulesMul {
    #[inline]
    fn clone(&self) -> UnitKilojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitKilojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilojoulesMul> for i8 {
    type Output = Quantity<i8, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for i16 {
    type Output = Quantity<i16, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for i32 {
    type Output = Quantity<i32, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for i64 {
    type Output = Quantity<i64, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for i128 {
    type Output = Quantity<i128, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for isize {
    type Output = Quantity<isize, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for u8 {
    type Output = Quantity<u8, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for u16 {
    type Output = Quantity<u16, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for u32 {
    type Output = Quantity<u32, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for u64 {
    type Output = Quantity<u64, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for u128 {
    type Output = Quantity<u128, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for usize {
    type Output = Quantity<usize, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for f32 {
    type Output = Quantity<f32, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
impl Mul<UnitKilojoulesMul> for f64 {
    type Output = Quantity<f64, UnitKilojoules>;
    fn mul(self, _: UnitKilojoulesMul) -> Self::Output {
        Quantity::new(self, UnitKilojoules)
    }
}
pub struct UnitHectojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectojoules {
    #[inline]
    fn clone(&self) -> UnitHectojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectojoules {
    #[inline]
    fn eq(&self, other: &UnitHectojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectojoules {
    fn default() -> Self {
        UnitHectojoules
    }
}
impl Add<UnitHectojoules> for UnitHectojoules {
    type Output = UnitHectojoules;
    #[inline]
    fn add(self, _: UnitHectojoules) -> Self::Output {
        UnitHectojoules
    }
}
impl AddAssign<UnitHectojoules> for UnitHectojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitHectojoules) {}
}
impl Sub<UnitHectojoules> for UnitHectojoules {
    type Output = UnitHectojoules;
    #[inline]
    fn sub(self, _: UnitHectojoules) -> Self::Output {
        UnitHectojoules
    }
}
impl SubAssign<UnitHectojoules> for UnitHectojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectojoules) {}
}
pub struct UnitHectojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectojoulesMul {
    #[inline]
    fn clone(&self) -> UnitHectojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitHectojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectojoulesMul> for i8 {
    type Output = Quantity<i8, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for i16 {
    type Output = Quantity<i16, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for i32 {
    type Output = Quantity<i32, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for i64 {
    type Output = Quantity<i64, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for i128 {
    type Output = Quantity<i128, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for isize {
    type Output = Quantity<isize, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for u8 {
    type Output = Quantity<u8, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for u16 {
    type Output = Quantity<u16, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for u32 {
    type Output = Quantity<u32, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for u64 {
    type Output = Quantity<u64, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for u128 {
    type Output = Quantity<u128, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for usize {
    type Output = Quantity<usize, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for f32 {
    type Output = Quantity<f32, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
impl Mul<UnitHectojoulesMul> for f64 {
    type Output = Quantity<f64, UnitHectojoules>;
    fn mul(self, _: UnitHectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitHectojoules)
    }
}
pub struct UnitDecajoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecajoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecajoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecajoules {
    #[inline]
    fn clone(&self) -> UnitDecajoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecajoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecajoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecajoules {
    #[inline]
    fn eq(&self, other: &UnitDecajoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecajoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecajoules {
    fn default() -> Self {
        UnitDecajoules
    }
}
impl Add<UnitDecajoules> for UnitDecajoules {
    type Output = UnitDecajoules;
    #[inline]
    fn add(self, _: UnitDecajoules) -> Self::Output {
        UnitDecajoules
    }
}
impl AddAssign<UnitDecajoules> for UnitDecajoules {
    #[inline]
    fn add_assign(&mut self, _: UnitDecajoules) {}
}
impl Sub<UnitDecajoules> for UnitDecajoules {
    type Output = UnitDecajoules;
    #[inline]
    fn sub(self, _: UnitDecajoules) -> Self::Output {
        UnitDecajoules
    }
}
impl SubAssign<UnitDecajoules> for UnitDecajoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecajoules) {}
}
pub struct UnitDecajoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecajoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecajoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecajoulesMul {
    #[inline]
    fn clone(&self) -> UnitDecajoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecajoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecajoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecajoulesMul {
    #[inline]
    fn eq(&self, other: &UnitDecajoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecajoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecajoulesMul> for i8 {
    type Output = Quantity<i8, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for i16 {
    type Output = Quantity<i16, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for i32 {
    type Output = Quantity<i32, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for i64 {
    type Output = Quantity<i64, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for i128 {
    type Output = Quantity<i128, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for isize {
    type Output = Quantity<isize, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for u8 {
    type Output = Quantity<u8, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for u16 {
    type Output = Quantity<u16, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for u32 {
    type Output = Quantity<u32, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for u64 {
    type Output = Quantity<u64, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for u128 {
    type Output = Quantity<u128, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for usize {
    type Output = Quantity<usize, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for f32 {
    type Output = Quantity<f32, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
impl Mul<UnitDecajoulesMul> for f64 {
    type Output = Quantity<f64, UnitDecajoules>;
    fn mul(self, _: UnitDecajoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecajoules)
    }
}
pub struct UnitDecijoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecijoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecijoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecijoules {
    #[inline]
    fn clone(&self) -> UnitDecijoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecijoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecijoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecijoules {
    #[inline]
    fn eq(&self, other: &UnitDecijoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecijoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecijoules {
    fn default() -> Self {
        UnitDecijoules
    }
}
impl Add<UnitDecijoules> for UnitDecijoules {
    type Output = UnitDecijoules;
    #[inline]
    fn add(self, _: UnitDecijoules) -> Self::Output {
        UnitDecijoules
    }
}
impl AddAssign<UnitDecijoules> for UnitDecijoules {
    #[inline]
    fn add_assign(&mut self, _: UnitDecijoules) {}
}
impl Sub<UnitDecijoules> for UnitDecijoules {
    type Output = UnitDecijoules;
    #[inline]
    fn sub(self, _: UnitDecijoules) -> Self::Output {
        UnitDecijoules
    }
}
impl SubAssign<UnitDecijoules> for UnitDecijoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecijoules) {}
}
pub struct UnitDecijoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecijoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecijoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecijoulesMul {
    #[inline]
    fn clone(&self) -> UnitDecijoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecijoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecijoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecijoulesMul {
    #[inline]
    fn eq(&self, other: &UnitDecijoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecijoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecijoulesMul> for i8 {
    type Output = Quantity<i8, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for i16 {
    type Output = Quantity<i16, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for i32 {
    type Output = Quantity<i32, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for i64 {
    type Output = Quantity<i64, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for i128 {
    type Output = Quantity<i128, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for isize {
    type Output = Quantity<isize, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for u8 {
    type Output = Quantity<u8, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for u16 {
    type Output = Quantity<u16, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for u32 {
    type Output = Quantity<u32, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for u64 {
    type Output = Quantity<u64, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for u128 {
    type Output = Quantity<u128, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for usize {
    type Output = Quantity<usize, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for f32 {
    type Output = Quantity<f32, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
impl Mul<UnitDecijoulesMul> for f64 {
    type Output = Quantity<f64, UnitDecijoules>;
    fn mul(self, _: UnitDecijoulesMul) -> Self::Output {
        Quantity::new(self, UnitDecijoules)
    }
}
pub struct UnitCentijoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentijoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentijoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentijoules {
    #[inline]
    fn clone(&self) -> UnitCentijoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentijoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentijoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentijoules {
    #[inline]
    fn eq(&self, other: &UnitCentijoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentijoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentijoules {
    fn default() -> Self {
        UnitCentijoules
    }
}
impl Add<UnitCentijoules> for UnitCentijoules {
    type Output = UnitCentijoules;
    #[inline]
    fn add(self, _: UnitCentijoules) -> Self::Output {
        UnitCentijoules
    }
}
impl AddAssign<UnitCentijoules> for UnitCentijoules {
    #[inline]
    fn add_assign(&mut self, _: UnitCentijoules) {}
}
impl Sub<UnitCentijoules> for UnitCentijoules {
    type Output = UnitCentijoules;
    #[inline]
    fn sub(self, _: UnitCentijoules) -> Self::Output {
        UnitCentijoules
    }
}
impl SubAssign<UnitCentijoules> for UnitCentijoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentijoules) {}
}
pub struct UnitCentijoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentijoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentijoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentijoulesMul {
    #[inline]
    fn clone(&self) -> UnitCentijoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentijoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentijoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentijoulesMul {
    #[inline]
    fn eq(&self, other: &UnitCentijoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentijoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentijoulesMul> for i8 {
    type Output = Quantity<i8, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for i16 {
    type Output = Quantity<i16, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for i32 {
    type Output = Quantity<i32, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for i64 {
    type Output = Quantity<i64, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for i128 {
    type Output = Quantity<i128, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for isize {
    type Output = Quantity<isize, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for u8 {
    type Output = Quantity<u8, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for u16 {
    type Output = Quantity<u16, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for u32 {
    type Output = Quantity<u32, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for u64 {
    type Output = Quantity<u64, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for u128 {
    type Output = Quantity<u128, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for usize {
    type Output = Quantity<usize, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for f32 {
    type Output = Quantity<f32, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
impl Mul<UnitCentijoulesMul> for f64 {
    type Output = Quantity<f64, UnitCentijoules>;
    fn mul(self, _: UnitCentijoulesMul) -> Self::Output {
        Quantity::new(self, UnitCentijoules)
    }
}
pub struct UnitMillijoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillijoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillijoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillijoules {
    #[inline]
    fn clone(&self) -> UnitMillijoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillijoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillijoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillijoules {
    #[inline]
    fn eq(&self, other: &UnitMillijoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillijoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillijoules {
    fn default() -> Self {
        UnitMillijoules
    }
}
impl Add<UnitMillijoules> for UnitMillijoules {
    type Output = UnitMillijoules;
    #[inline]
    fn add(self, _: UnitMillijoules) -> Self::Output {
        UnitMillijoules
    }
}
impl AddAssign<UnitMillijoules> for UnitMillijoules {
    #[inline]
    fn add_assign(&mut self, _: UnitMillijoules) {}
}
impl Sub<UnitMillijoules> for UnitMillijoules {
    type Output = UnitMillijoules;
    #[inline]
    fn sub(self, _: UnitMillijoules) -> Self::Output {
        UnitMillijoules
    }
}
impl SubAssign<UnitMillijoules> for UnitMillijoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillijoules) {}
}
pub struct UnitMillijoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillijoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillijoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillijoulesMul {
    #[inline]
    fn clone(&self) -> UnitMillijoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillijoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillijoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillijoulesMul {
    #[inline]
    fn eq(&self, other: &UnitMillijoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillijoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillijoulesMul> for i8 {
    type Output = Quantity<i8, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for i16 {
    type Output = Quantity<i16, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for i32 {
    type Output = Quantity<i32, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for i64 {
    type Output = Quantity<i64, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for i128 {
    type Output = Quantity<i128, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for isize {
    type Output = Quantity<isize, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for u8 {
    type Output = Quantity<u8, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for u16 {
    type Output = Quantity<u16, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for u32 {
    type Output = Quantity<u32, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for u64 {
    type Output = Quantity<u64, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for u128 {
    type Output = Quantity<u128, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for usize {
    type Output = Quantity<usize, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for f32 {
    type Output = Quantity<f32, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
impl Mul<UnitMillijoulesMul> for f64 {
    type Output = Quantity<f64, UnitMillijoules>;
    fn mul(self, _: UnitMillijoulesMul) -> Self::Output {
        Quantity::new(self, UnitMillijoules)
    }
}
pub struct UnitMicrojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrojoules {
    #[inline]
    fn clone(&self) -> UnitMicrojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrojoules {
    #[inline]
    fn eq(&self, other: &UnitMicrojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrojoules {
    fn default() -> Self {
        UnitMicrojoules
    }
}
impl Add<UnitMicrojoules> for UnitMicrojoules {
    type Output = UnitMicrojoules;
    #[inline]
    fn add(self, _: UnitMicrojoules) -> Self::Output {
        UnitMicrojoules
    }
}
impl AddAssign<UnitMicrojoules> for UnitMicrojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrojoules) {}
}
impl Sub<UnitMicrojoules> for UnitMicrojoules {
    type Output = UnitMicrojoules;
    #[inline]
    fn sub(self, _: UnitMicrojoules) -> Self::Output {
        UnitMicrojoules
    }
}
impl SubAssign<UnitMicrojoules> for UnitMicrojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrojoules) {}
}
pub struct UnitMicrojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrojoulesMul {
    #[inline]
    fn clone(&self) -> UnitMicrojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitMicrojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrojoulesMul> for i8 {
    type Output = Quantity<i8, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for i16 {
    type Output = Quantity<i16, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for i32 {
    type Output = Quantity<i32, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for i64 {
    type Output = Quantity<i64, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for i128 {
    type Output = Quantity<i128, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for isize {
    type Output = Quantity<isize, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for u8 {
    type Output = Quantity<u8, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for u16 {
    type Output = Quantity<u16, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for u32 {
    type Output = Quantity<u32, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for u64 {
    type Output = Quantity<u64, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for u128 {
    type Output = Quantity<u128, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for usize {
    type Output = Quantity<usize, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for f32 {
    type Output = Quantity<f32, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
impl Mul<UnitMicrojoulesMul> for f64 {
    type Output = Quantity<f64, UnitMicrojoules>;
    fn mul(self, _: UnitMicrojoulesMul) -> Self::Output {
        Quantity::new(self, UnitMicrojoules)
    }
}
pub struct UnitNanojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanojoules {
    #[inline]
    fn clone(&self) -> UnitNanojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanojoules {
    #[inline]
    fn eq(&self, other: &UnitNanojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanojoules {
    fn default() -> Self {
        UnitNanojoules
    }
}
impl Add<UnitNanojoules> for UnitNanojoules {
    type Output = UnitNanojoules;
    #[inline]
    fn add(self, _: UnitNanojoules) -> Self::Output {
        UnitNanojoules
    }
}
impl AddAssign<UnitNanojoules> for UnitNanojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitNanojoules) {}
}
impl Sub<UnitNanojoules> for UnitNanojoules {
    type Output = UnitNanojoules;
    #[inline]
    fn sub(self, _: UnitNanojoules) -> Self::Output {
        UnitNanojoules
    }
}
impl SubAssign<UnitNanojoules> for UnitNanojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanojoules) {}
}
pub struct UnitNanojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanojoulesMul {
    #[inline]
    fn clone(&self) -> UnitNanojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitNanojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanojoulesMul> for i8 {
    type Output = Quantity<i8, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for i16 {
    type Output = Quantity<i16, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for i32 {
    type Output = Quantity<i32, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for i64 {
    type Output = Quantity<i64, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for i128 {
    type Output = Quantity<i128, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for isize {
    type Output = Quantity<isize, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for u8 {
    type Output = Quantity<u8, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for u16 {
    type Output = Quantity<u16, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for u32 {
    type Output = Quantity<u32, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for u64 {
    type Output = Quantity<u64, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for u128 {
    type Output = Quantity<u128, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for usize {
    type Output = Quantity<usize, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for f32 {
    type Output = Quantity<f32, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
impl Mul<UnitNanojoulesMul> for f64 {
    type Output = Quantity<f64, UnitNanojoules>;
    fn mul(self, _: UnitNanojoulesMul) -> Self::Output {
        Quantity::new(self, UnitNanojoules)
    }
}
pub struct UnitPicojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicojoules {
    #[inline]
    fn clone(&self) -> UnitPicojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicojoules {
    #[inline]
    fn eq(&self, other: &UnitPicojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicojoules {
    fn default() -> Self {
        UnitPicojoules
    }
}
impl Add<UnitPicojoules> for UnitPicojoules {
    type Output = UnitPicojoules;
    #[inline]
    fn add(self, _: UnitPicojoules) -> Self::Output {
        UnitPicojoules
    }
}
impl AddAssign<UnitPicojoules> for UnitPicojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitPicojoules) {}
}
impl Sub<UnitPicojoules> for UnitPicojoules {
    type Output = UnitPicojoules;
    #[inline]
    fn sub(self, _: UnitPicojoules) -> Self::Output {
        UnitPicojoules
    }
}
impl SubAssign<UnitPicojoules> for UnitPicojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicojoules) {}
}
pub struct UnitPicojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicojoulesMul {
    #[inline]
    fn clone(&self) -> UnitPicojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitPicojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicojoulesMul> for i8 {
    type Output = Quantity<i8, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for i16 {
    type Output = Quantity<i16, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for i32 {
    type Output = Quantity<i32, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for i64 {
    type Output = Quantity<i64, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for i128 {
    type Output = Quantity<i128, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for isize {
    type Output = Quantity<isize, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for u8 {
    type Output = Quantity<u8, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for u16 {
    type Output = Quantity<u16, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for u32 {
    type Output = Quantity<u32, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for u64 {
    type Output = Quantity<u64, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for u128 {
    type Output = Quantity<u128, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for usize {
    type Output = Quantity<usize, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for f32 {
    type Output = Quantity<f32, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
impl Mul<UnitPicojoulesMul> for f64 {
    type Output = Quantity<f64, UnitPicojoules>;
    fn mul(self, _: UnitPicojoulesMul) -> Self::Output {
        Quantity::new(self, UnitPicojoules)
    }
}
pub struct UnitFemtojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtojoules {
    #[inline]
    fn clone(&self) -> UnitFemtojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtojoules {
    #[inline]
    fn eq(&self, other: &UnitFemtojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtojoules {
    fn default() -> Self {
        UnitFemtojoules
    }
}
impl Add<UnitFemtojoules> for UnitFemtojoules {
    type Output = UnitFemtojoules;
    #[inline]
    fn add(self, _: UnitFemtojoules) -> Self::Output {
        UnitFemtojoules
    }
}
impl AddAssign<UnitFemtojoules> for UnitFemtojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtojoules) {}
}
impl Sub<UnitFemtojoules> for UnitFemtojoules {
    type Output = UnitFemtojoules;
    #[inline]
    fn sub(self, _: UnitFemtojoules) -> Self::Output {
        UnitFemtojoules
    }
}
impl SubAssign<UnitFemtojoules> for UnitFemtojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtojoules) {}
}
pub struct UnitFemtojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtojoulesMul {
    #[inline]
    fn clone(&self) -> UnitFemtojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtojoulesMul> for i8 {
    type Output = Quantity<i8, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for i16 {
    type Output = Quantity<i16, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for i32 {
    type Output = Quantity<i32, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for i64 {
    type Output = Quantity<i64, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for i128 {
    type Output = Quantity<i128, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for isize {
    type Output = Quantity<isize, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for u8 {
    type Output = Quantity<u8, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for u16 {
    type Output = Quantity<u16, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for u32 {
    type Output = Quantity<u32, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for u64 {
    type Output = Quantity<u64, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for u128 {
    type Output = Quantity<u128, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for usize {
    type Output = Quantity<usize, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for f32 {
    type Output = Quantity<f32, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
impl Mul<UnitFemtojoulesMul> for f64 {
    type Output = Quantity<f64, UnitFemtojoules>;
    fn mul(self, _: UnitFemtojoulesMul) -> Self::Output {
        Quantity::new(self, UnitFemtojoules)
    }
}
pub struct UnitAttojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttojoules {
    #[inline]
    fn clone(&self) -> UnitAttojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttojoules {
    #[inline]
    fn eq(&self, other: &UnitAttojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttojoules {
    fn default() -> Self {
        UnitAttojoules
    }
}
impl Add<UnitAttojoules> for UnitAttojoules {
    type Output = UnitAttojoules;
    #[inline]
    fn add(self, _: UnitAttojoules) -> Self::Output {
        UnitAttojoules
    }
}
impl AddAssign<UnitAttojoules> for UnitAttojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitAttojoules) {}
}
impl Sub<UnitAttojoules> for UnitAttojoules {
    type Output = UnitAttojoules;
    #[inline]
    fn sub(self, _: UnitAttojoules) -> Self::Output {
        UnitAttojoules
    }
}
impl SubAssign<UnitAttojoules> for UnitAttojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttojoules) {}
}
pub struct UnitAttojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttojoulesMul {
    #[inline]
    fn clone(&self) -> UnitAttojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitAttojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttojoulesMul> for i8 {
    type Output = Quantity<i8, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for i16 {
    type Output = Quantity<i16, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for i32 {
    type Output = Quantity<i32, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for i64 {
    type Output = Quantity<i64, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for i128 {
    type Output = Quantity<i128, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for isize {
    type Output = Quantity<isize, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for u8 {
    type Output = Quantity<u8, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for u16 {
    type Output = Quantity<u16, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for u32 {
    type Output = Quantity<u32, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for u64 {
    type Output = Quantity<u64, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for u128 {
    type Output = Quantity<u128, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for usize {
    type Output = Quantity<usize, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for f32 {
    type Output = Quantity<f32, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
impl Mul<UnitAttojoulesMul> for f64 {
    type Output = Quantity<f64, UnitAttojoules>;
    fn mul(self, _: UnitAttojoulesMul) -> Self::Output {
        Quantity::new(self, UnitAttojoules)
    }
}
pub struct UnitZeptojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptojoules {
    #[inline]
    fn clone(&self) -> UnitZeptojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptojoules {
    #[inline]
    fn eq(&self, other: &UnitZeptojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptojoules {
    fn default() -> Self {
        UnitZeptojoules
    }
}
impl Add<UnitZeptojoules> for UnitZeptojoules {
    type Output = UnitZeptojoules;
    #[inline]
    fn add(self, _: UnitZeptojoules) -> Self::Output {
        UnitZeptojoules
    }
}
impl AddAssign<UnitZeptojoules> for UnitZeptojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptojoules) {}
}
impl Sub<UnitZeptojoules> for UnitZeptojoules {
    type Output = UnitZeptojoules;
    #[inline]
    fn sub(self, _: UnitZeptojoules) -> Self::Output {
        UnitZeptojoules
    }
}
impl SubAssign<UnitZeptojoules> for UnitZeptojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptojoules) {}
}
pub struct UnitZeptojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptojoulesMul {
    #[inline]
    fn clone(&self) -> UnitZeptojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptojoulesMul> for i8 {
    type Output = Quantity<i8, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for i16 {
    type Output = Quantity<i16, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for i32 {
    type Output = Quantity<i32, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for i64 {
    type Output = Quantity<i64, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for i128 {
    type Output = Quantity<i128, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for isize {
    type Output = Quantity<isize, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for u8 {
    type Output = Quantity<u8, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for u16 {
    type Output = Quantity<u16, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for u32 {
    type Output = Quantity<u32, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for u64 {
    type Output = Quantity<u64, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for u128 {
    type Output = Quantity<u128, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for usize {
    type Output = Quantity<usize, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for f32 {
    type Output = Quantity<f32, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
impl Mul<UnitZeptojoulesMul> for f64 {
    type Output = Quantity<f64, UnitZeptojoules>;
    fn mul(self, _: UnitZeptojoulesMul) -> Self::Output {
        Quantity::new(self, UnitZeptojoules)
    }
}
pub struct UnitYoctojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctojoules {
    #[inline]
    fn clone(&self) -> UnitYoctojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctojoules {
    #[inline]
    fn eq(&self, other: &UnitYoctojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctojoules {
    fn default() -> Self {
        UnitYoctojoules
    }
}
impl Add<UnitYoctojoules> for UnitYoctojoules {
    type Output = UnitYoctojoules;
    #[inline]
    fn add(self, _: UnitYoctojoules) -> Self::Output {
        UnitYoctojoules
    }
}
impl AddAssign<UnitYoctojoules> for UnitYoctojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctojoules) {}
}
impl Sub<UnitYoctojoules> for UnitYoctojoules {
    type Output = UnitYoctojoules;
    #[inline]
    fn sub(self, _: UnitYoctojoules) -> Self::Output {
        UnitYoctojoules
    }
}
impl SubAssign<UnitYoctojoules> for UnitYoctojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctojoules) {}
}
pub struct UnitYoctojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctojoulesMul {
    #[inline]
    fn clone(&self) -> UnitYoctojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctojoulesMul> for i8 {
    type Output = Quantity<i8, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for i16 {
    type Output = Quantity<i16, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for i32 {
    type Output = Quantity<i32, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for i64 {
    type Output = Quantity<i64, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for i128 {
    type Output = Quantity<i128, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for isize {
    type Output = Quantity<isize, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for u8 {
    type Output = Quantity<u8, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for u16 {
    type Output = Quantity<u16, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for u32 {
    type Output = Quantity<u32, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for u64 {
    type Output = Quantity<u64, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for u128 {
    type Output = Quantity<u128, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for usize {
    type Output = Quantity<usize, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for f32 {
    type Output = Quantity<f32, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
impl Mul<UnitYoctojoulesMul> for f64 {
    type Output = Quantity<f64, UnitYoctojoules>;
    fn mul(self, _: UnitYoctojoulesMul) -> Self::Output {
        Quantity::new(self, UnitYoctojoules)
    }
}
pub struct UnitRontojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontojoules {
    #[inline]
    fn clone(&self) -> UnitRontojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontojoules {
    #[inline]
    fn eq(&self, other: &UnitRontojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontojoules {
    fn default() -> Self {
        UnitRontojoules
    }
}
impl Add<UnitRontojoules> for UnitRontojoules {
    type Output = UnitRontojoules;
    #[inline]
    fn add(self, _: UnitRontojoules) -> Self::Output {
        UnitRontojoules
    }
}
impl AddAssign<UnitRontojoules> for UnitRontojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitRontojoules) {}
}
impl Sub<UnitRontojoules> for UnitRontojoules {
    type Output = UnitRontojoules;
    #[inline]
    fn sub(self, _: UnitRontojoules) -> Self::Output {
        UnitRontojoules
    }
}
impl SubAssign<UnitRontojoules> for UnitRontojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontojoules) {}
}
pub struct UnitRontojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontojoulesMul {
    #[inline]
    fn clone(&self) -> UnitRontojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitRontojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontojoulesMul> for i8 {
    type Output = Quantity<i8, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for i16 {
    type Output = Quantity<i16, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for i32 {
    type Output = Quantity<i32, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for i64 {
    type Output = Quantity<i64, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for i128 {
    type Output = Quantity<i128, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for isize {
    type Output = Quantity<isize, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for u8 {
    type Output = Quantity<u8, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for u16 {
    type Output = Quantity<u16, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for u32 {
    type Output = Quantity<u32, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for u64 {
    type Output = Quantity<u64, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for u128 {
    type Output = Quantity<u128, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for usize {
    type Output = Quantity<usize, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for f32 {
    type Output = Quantity<f32, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
impl Mul<UnitRontojoulesMul> for f64 {
    type Output = Quantity<f64, UnitRontojoules>;
    fn mul(self, _: UnitRontojoulesMul) -> Self::Output {
        Quantity::new(self, UnitRontojoules)
    }
}
pub struct UnitQuectojoules;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectojoules {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectojoules")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectojoules {
    #[inline]
    fn clone(&self) -> UnitQuectojoules {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectojoules {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectojoules {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectojoules {
    #[inline]
    fn eq(&self, other: &UnitQuectojoules) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectojoules {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectojoules {
    fn default() -> Self {
        UnitQuectojoules
    }
}
impl Add<UnitQuectojoules> for UnitQuectojoules {
    type Output = UnitQuectojoules;
    #[inline]
    fn add(self, _: UnitQuectojoules) -> Self::Output {
        UnitQuectojoules
    }
}
impl AddAssign<UnitQuectojoules> for UnitQuectojoules {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectojoules) {}
}
impl Sub<UnitQuectojoules> for UnitQuectojoules {
    type Output = UnitQuectojoules;
    #[inline]
    fn sub(self, _: UnitQuectojoules) -> Self::Output {
        UnitQuectojoules
    }
}
impl SubAssign<UnitQuectojoules> for UnitQuectojoules {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectojoules) {}
}
pub struct UnitQuectojoulesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectojoulesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectojoulesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectojoulesMul {
    #[inline]
    fn clone(&self) -> UnitQuectojoulesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectojoulesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectojoulesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectojoulesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectojoulesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectojoulesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectojoulesMul> for i8 {
    type Output = Quantity<i8, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for i16 {
    type Output = Quantity<i16, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for i32 {
    type Output = Quantity<i32, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for i64 {
    type Output = Quantity<i64, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for i128 {
    type Output = Quantity<i128, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for isize {
    type Output = Quantity<isize, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for u8 {
    type Output = Quantity<u8, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for u16 {
    type Output = Quantity<u16, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for u32 {
    type Output = Quantity<u32, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for u64 {
    type Output = Quantity<u64, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for u128 {
    type Output = Quantity<u128, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for usize {
    type Output = Quantity<usize, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for f32 {
    type Output = Quantity<f32, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
impl Mul<UnitQuectojoulesMul> for f64 {
    type Output = Quantity<f64, UnitQuectojoules>;
    fn mul(self, _: UnitQuectojoulesMul) -> Self::Output {
        Quantity::new(self, UnitQuectojoules)
    }
}
pub type Joules<T> = Quantity<T, UnitJoules>;
#[allow(non_upper_case_globals)]
pub static Joules: UnitJoulesMul = UnitJoulesMul;
pub type Quettajoules<T> = Quantity<T, UnitQuettajoules>;
#[allow(non_upper_case_globals)]
pub static Quettajoules: UnitQuettajoulesMul = UnitQuettajoulesMul;
pub type Ronnajoules<T> = Quantity<T, UnitRonnajoules>;
#[allow(non_upper_case_globals)]
pub static Ronnajoules: UnitRonnajoulesMul = UnitRonnajoulesMul;
pub type Yottajoules<T> = Quantity<T, UnitYottajoules>;
#[allow(non_upper_case_globals)]
pub static Yottajoules: UnitYottajoulesMul = UnitYottajoulesMul;
pub type Zettajoules<T> = Quantity<T, UnitZettajoules>;
#[allow(non_upper_case_globals)]
pub static Zettajoules: UnitZettajoulesMul = UnitZettajoulesMul;
pub type Exajoules<T> = Quantity<T, UnitExajoules>;
#[allow(non_upper_case_globals)]
pub static Exajoules: UnitExajoulesMul = UnitExajoulesMul;
pub type Petajoules<T> = Quantity<T, UnitPetajoules>;
#[allow(non_upper_case_globals)]
pub static Petajoules: UnitPetajoulesMul = UnitPetajoulesMul;
pub type Terajoules<T> = Quantity<T, UnitTerajoules>;
#[allow(non_upper_case_globals)]
pub static Terajoules: UnitTerajoulesMul = UnitTerajoulesMul;
pub type Gigajoules<T> = Quantity<T, UnitGigajoules>;
#[allow(non_upper_case_globals)]
pub static Gigajoules: UnitGigajoulesMul = UnitGigajoulesMul;
pub type Megajoules<T> = Quantity<T, UnitMegajoules>;
#[allow(non_upper_case_globals)]
pub static Megajoules: UnitMegajoulesMul = UnitMegajoulesMul;
pub type Kilojoules<T> = Quantity<T, UnitKilojoules>;
#[allow(non_upper_case_globals)]
pub static Kilojoules: UnitKilojoulesMul = UnitKilojoulesMul;
pub type Hectojoules<T> = Quantity<T, UnitHectojoules>;
#[allow(non_upper_case_globals)]
pub static Hectojoules: UnitHectojoulesMul = UnitHectojoulesMul;
pub type Decajoules<T> = Quantity<T, UnitDecajoules>;
#[allow(non_upper_case_globals)]
pub static Decajoules: UnitDecajoulesMul = UnitDecajoulesMul;
pub type Decijoules<T> = Quantity<T, UnitDecijoules>;
#[allow(non_upper_case_globals)]
pub static Decijoules: UnitDecijoulesMul = UnitDecijoulesMul;
pub type Centijoules<T> = Quantity<T, UnitCentijoules>;
#[allow(non_upper_case_globals)]
pub static Centijoules: UnitCentijoulesMul = UnitCentijoulesMul;
pub type Millijoules<T> = Quantity<T, UnitMillijoules>;
#[allow(non_upper_case_globals)]
pub static Millijoules: UnitMillijoulesMul = UnitMillijoulesMul;
pub type Microjoules<T> = Quantity<T, UnitMicrojoules>;
#[allow(non_upper_case_globals)]
pub static Microjoules: UnitMicrojoulesMul = UnitMicrojoulesMul;
pub type Nanojoules<T> = Quantity<T, UnitNanojoules>;
#[allow(non_upper_case_globals)]
pub static Nanojoules: UnitNanojoulesMul = UnitNanojoulesMul;
pub type Picojoules<T> = Quantity<T, UnitPicojoules>;
#[allow(non_upper_case_globals)]
pub static Picojoules: UnitPicojoulesMul = UnitPicojoulesMul;
pub type Femtojoules<T> = Quantity<T, UnitFemtojoules>;
#[allow(non_upper_case_globals)]
pub static Femtojoules: UnitFemtojoulesMul = UnitFemtojoulesMul;
pub type Attojoules<T> = Quantity<T, UnitAttojoules>;
#[allow(non_upper_case_globals)]
pub static Attojoules: UnitAttojoulesMul = UnitAttojoulesMul;
pub type Zeptojoules<T> = Quantity<T, UnitZeptojoules>;
#[allow(non_upper_case_globals)]
pub static Zeptojoules: UnitZeptojoulesMul = UnitZeptojoulesMul;
pub type Yoctojoules<T> = Quantity<T, UnitYoctojoules>;
#[allow(non_upper_case_globals)]
pub static Yoctojoules: UnitYoctojoulesMul = UnitYoctojoulesMul;
pub type Rontojoules<T> = Quantity<T, UnitRontojoules>;
#[allow(non_upper_case_globals)]
pub static Rontojoules: UnitRontojoulesMul = UnitRontojoulesMul;
pub type Quectojoules<T> = Quantity<T, UnitQuectojoules>;
#[allow(non_upper_case_globals)]
pub static Quectojoules: UnitQuectojoulesMul = UnitQuectojoulesMul;
pub struct UnitWatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitWatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitWatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitWatts {
    #[inline]
    fn clone(&self) -> UnitWatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitWatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitWatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitWatts {
    #[inline]
    fn eq(&self, other: &UnitWatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitWatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitWatts {
    fn default() -> Self {
        UnitWatts
    }
}
impl Add<UnitWatts> for UnitWatts {
    type Output = UnitWatts;
    #[inline]
    fn add(self, _: UnitWatts) -> Self::Output {
        UnitWatts
    }
}
impl AddAssign<UnitWatts> for UnitWatts {
    #[inline]
    fn add_assign(&mut self, _: UnitWatts) {}
}
impl Sub<UnitWatts> for UnitWatts {
    type Output = UnitWatts;
    #[inline]
    fn sub(self, _: UnitWatts) -> Self::Output {
        UnitWatts
    }
}
impl SubAssign<UnitWatts> for UnitWatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitWatts) {}
}
pub struct UnitWattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitWattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitWattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitWattsMul {
    #[inline]
    fn clone(&self) -> UnitWattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitWattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitWattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitWattsMul {
    #[inline]
    fn eq(&self, other: &UnitWattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitWattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitWattsMul> for i8 {
    type Output = Quantity<i8, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for i16 {
    type Output = Quantity<i16, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for i32 {
    type Output = Quantity<i32, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for i64 {
    type Output = Quantity<i64, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for i128 {
    type Output = Quantity<i128, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for isize {
    type Output = Quantity<isize, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for u8 {
    type Output = Quantity<u8, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for u16 {
    type Output = Quantity<u16, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for u32 {
    type Output = Quantity<u32, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for u64 {
    type Output = Quantity<u64, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for u128 {
    type Output = Quantity<u128, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for usize {
    type Output = Quantity<usize, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for f32 {
    type Output = Quantity<f32, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
impl Mul<UnitWattsMul> for f64 {
    type Output = Quantity<f64, UnitWatts>;
    fn mul(self, _: UnitWattsMul) -> Self::Output {
        Quantity::new(self, UnitWatts)
    }
}
pub struct UnitQuettawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettawatts {
    #[inline]
    fn clone(&self) -> UnitQuettawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettawatts {
    #[inline]
    fn eq(&self, other: &UnitQuettawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettawatts {
    fn default() -> Self {
        UnitQuettawatts
    }
}
impl Add<UnitQuettawatts> for UnitQuettawatts {
    type Output = UnitQuettawatts;
    #[inline]
    fn add(self, _: UnitQuettawatts) -> Self::Output {
        UnitQuettawatts
    }
}
impl AddAssign<UnitQuettawatts> for UnitQuettawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettawatts) {}
}
impl Sub<UnitQuettawatts> for UnitQuettawatts {
    type Output = UnitQuettawatts;
    #[inline]
    fn sub(self, _: UnitQuettawatts) -> Self::Output {
        UnitQuettawatts
    }
}
impl SubAssign<UnitQuettawatts> for UnitQuettawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettawatts) {}
}
pub struct UnitQuettawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettawattsMul {
    #[inline]
    fn clone(&self) -> UnitQuettawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettawattsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettawattsMul> for i8 {
    type Output = Quantity<i8, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for i16 {
    type Output = Quantity<i16, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for i32 {
    type Output = Quantity<i32, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for i64 {
    type Output = Quantity<i64, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for i128 {
    type Output = Quantity<i128, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for isize {
    type Output = Quantity<isize, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for u8 {
    type Output = Quantity<u8, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for u16 {
    type Output = Quantity<u16, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for u32 {
    type Output = Quantity<u32, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for u64 {
    type Output = Quantity<u64, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for u128 {
    type Output = Quantity<u128, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for usize {
    type Output = Quantity<usize, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for f32 {
    type Output = Quantity<f32, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
impl Mul<UnitQuettawattsMul> for f64 {
    type Output = Quantity<f64, UnitQuettawatts>;
    fn mul(self, _: UnitQuettawattsMul) -> Self::Output {
        Quantity::new(self, UnitQuettawatts)
    }
}
pub struct UnitRonnawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnawatts {
    #[inline]
    fn clone(&self) -> UnitRonnawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnawatts {
    #[inline]
    fn eq(&self, other: &UnitRonnawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnawatts {
    fn default() -> Self {
        UnitRonnawatts
    }
}
impl Add<UnitRonnawatts> for UnitRonnawatts {
    type Output = UnitRonnawatts;
    #[inline]
    fn add(self, _: UnitRonnawatts) -> Self::Output {
        UnitRonnawatts
    }
}
impl AddAssign<UnitRonnawatts> for UnitRonnawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnawatts) {}
}
impl Sub<UnitRonnawatts> for UnitRonnawatts {
    type Output = UnitRonnawatts;
    #[inline]
    fn sub(self, _: UnitRonnawatts) -> Self::Output {
        UnitRonnawatts
    }
}
impl SubAssign<UnitRonnawatts> for UnitRonnawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnawatts) {}
}
pub struct UnitRonnawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnawattsMul {
    #[inline]
    fn clone(&self) -> UnitRonnawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnawattsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnawattsMul> for i8 {
    type Output = Quantity<i8, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for i16 {
    type Output = Quantity<i16, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for i32 {
    type Output = Quantity<i32, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for i64 {
    type Output = Quantity<i64, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for i128 {
    type Output = Quantity<i128, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for isize {
    type Output = Quantity<isize, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for u8 {
    type Output = Quantity<u8, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for u16 {
    type Output = Quantity<u16, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for u32 {
    type Output = Quantity<u32, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for u64 {
    type Output = Quantity<u64, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for u128 {
    type Output = Quantity<u128, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for usize {
    type Output = Quantity<usize, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for f32 {
    type Output = Quantity<f32, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
impl Mul<UnitRonnawattsMul> for f64 {
    type Output = Quantity<f64, UnitRonnawatts>;
    fn mul(self, _: UnitRonnawattsMul) -> Self::Output {
        Quantity::new(self, UnitRonnawatts)
    }
}
pub struct UnitYottawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottawatts {
    #[inline]
    fn clone(&self) -> UnitYottawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottawatts {
    #[inline]
    fn eq(&self, other: &UnitYottawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottawatts {
    fn default() -> Self {
        UnitYottawatts
    }
}
impl Add<UnitYottawatts> for UnitYottawatts {
    type Output = UnitYottawatts;
    #[inline]
    fn add(self, _: UnitYottawatts) -> Self::Output {
        UnitYottawatts
    }
}
impl AddAssign<UnitYottawatts> for UnitYottawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitYottawatts) {}
}
impl Sub<UnitYottawatts> for UnitYottawatts {
    type Output = UnitYottawatts;
    #[inline]
    fn sub(self, _: UnitYottawatts) -> Self::Output {
        UnitYottawatts
    }
}
impl SubAssign<UnitYottawatts> for UnitYottawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottawatts) {}
}
pub struct UnitYottawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottawattsMul {
    #[inline]
    fn clone(&self) -> UnitYottawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottawattsMul {
    #[inline]
    fn eq(&self, other: &UnitYottawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottawattsMul> for i8 {
    type Output = Quantity<i8, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for i16 {
    type Output = Quantity<i16, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for i32 {
    type Output = Quantity<i32, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for i64 {
    type Output = Quantity<i64, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for i128 {
    type Output = Quantity<i128, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for isize {
    type Output = Quantity<isize, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for u8 {
    type Output = Quantity<u8, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for u16 {
    type Output = Quantity<u16, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for u32 {
    type Output = Quantity<u32, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for u64 {
    type Output = Quantity<u64, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for u128 {
    type Output = Quantity<u128, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for usize {
    type Output = Quantity<usize, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for f32 {
    type Output = Quantity<f32, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
impl Mul<UnitYottawattsMul> for f64 {
    type Output = Quantity<f64, UnitYottawatts>;
    fn mul(self, _: UnitYottawattsMul) -> Self::Output {
        Quantity::new(self, UnitYottawatts)
    }
}
pub struct UnitZettawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettawatts {
    #[inline]
    fn clone(&self) -> UnitZettawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettawatts {
    #[inline]
    fn eq(&self, other: &UnitZettawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettawatts {
    fn default() -> Self {
        UnitZettawatts
    }
}
impl Add<UnitZettawatts> for UnitZettawatts {
    type Output = UnitZettawatts;
    #[inline]
    fn add(self, _: UnitZettawatts) -> Self::Output {
        UnitZettawatts
    }
}
impl AddAssign<UnitZettawatts> for UnitZettawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitZettawatts) {}
}
impl Sub<UnitZettawatts> for UnitZettawatts {
    type Output = UnitZettawatts;
    #[inline]
    fn sub(self, _: UnitZettawatts) -> Self::Output {
        UnitZettawatts
    }
}
impl SubAssign<UnitZettawatts> for UnitZettawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettawatts) {}
}
pub struct UnitZettawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettawattsMul {
    #[inline]
    fn clone(&self) -> UnitZettawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettawattsMul {
    #[inline]
    fn eq(&self, other: &UnitZettawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettawattsMul> for i8 {
    type Output = Quantity<i8, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for i16 {
    type Output = Quantity<i16, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for i32 {
    type Output = Quantity<i32, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for i64 {
    type Output = Quantity<i64, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for i128 {
    type Output = Quantity<i128, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for isize {
    type Output = Quantity<isize, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for u8 {
    type Output = Quantity<u8, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for u16 {
    type Output = Quantity<u16, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for u32 {
    type Output = Quantity<u32, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for u64 {
    type Output = Quantity<u64, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for u128 {
    type Output = Quantity<u128, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for usize {
    type Output = Quantity<usize, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for f32 {
    type Output = Quantity<f32, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
impl Mul<UnitZettawattsMul> for f64 {
    type Output = Quantity<f64, UnitZettawatts>;
    fn mul(self, _: UnitZettawattsMul) -> Self::Output {
        Quantity::new(self, UnitZettawatts)
    }
}
pub struct UnitExawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExawatts {
    #[inline]
    fn clone(&self) -> UnitExawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExawatts {
    #[inline]
    fn eq(&self, other: &UnitExawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExawatts {
    fn default() -> Self {
        UnitExawatts
    }
}
impl Add<UnitExawatts> for UnitExawatts {
    type Output = UnitExawatts;
    #[inline]
    fn add(self, _: UnitExawatts) -> Self::Output {
        UnitExawatts
    }
}
impl AddAssign<UnitExawatts> for UnitExawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitExawatts) {}
}
impl Sub<UnitExawatts> for UnitExawatts {
    type Output = UnitExawatts;
    #[inline]
    fn sub(self, _: UnitExawatts) -> Self::Output {
        UnitExawatts
    }
}
impl SubAssign<UnitExawatts> for UnitExawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitExawatts) {}
}
pub struct UnitExawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExawattsMul {
    #[inline]
    fn clone(&self) -> UnitExawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExawattsMul {
    #[inline]
    fn eq(&self, other: &UnitExawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExawattsMul> for i8 {
    type Output = Quantity<i8, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for i16 {
    type Output = Quantity<i16, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for i32 {
    type Output = Quantity<i32, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for i64 {
    type Output = Quantity<i64, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for i128 {
    type Output = Quantity<i128, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for isize {
    type Output = Quantity<isize, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for u8 {
    type Output = Quantity<u8, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for u16 {
    type Output = Quantity<u16, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for u32 {
    type Output = Quantity<u32, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for u64 {
    type Output = Quantity<u64, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for u128 {
    type Output = Quantity<u128, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for usize {
    type Output = Quantity<usize, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for f32 {
    type Output = Quantity<f32, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
impl Mul<UnitExawattsMul> for f64 {
    type Output = Quantity<f64, UnitExawatts>;
    fn mul(self, _: UnitExawattsMul) -> Self::Output {
        Quantity::new(self, UnitExawatts)
    }
}
pub struct UnitPetawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetawatts {
    #[inline]
    fn clone(&self) -> UnitPetawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetawatts {
    #[inline]
    fn eq(&self, other: &UnitPetawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetawatts {
    fn default() -> Self {
        UnitPetawatts
    }
}
impl Add<UnitPetawatts> for UnitPetawatts {
    type Output = UnitPetawatts;
    #[inline]
    fn add(self, _: UnitPetawatts) -> Self::Output {
        UnitPetawatts
    }
}
impl AddAssign<UnitPetawatts> for UnitPetawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitPetawatts) {}
}
impl Sub<UnitPetawatts> for UnitPetawatts {
    type Output = UnitPetawatts;
    #[inline]
    fn sub(self, _: UnitPetawatts) -> Self::Output {
        UnitPetawatts
    }
}
impl SubAssign<UnitPetawatts> for UnitPetawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetawatts) {}
}
pub struct UnitPetawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetawattsMul {
    #[inline]
    fn clone(&self) -> UnitPetawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetawattsMul {
    #[inline]
    fn eq(&self, other: &UnitPetawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetawattsMul> for i8 {
    type Output = Quantity<i8, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for i16 {
    type Output = Quantity<i16, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for i32 {
    type Output = Quantity<i32, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for i64 {
    type Output = Quantity<i64, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for i128 {
    type Output = Quantity<i128, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for isize {
    type Output = Quantity<isize, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for u8 {
    type Output = Quantity<u8, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for u16 {
    type Output = Quantity<u16, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for u32 {
    type Output = Quantity<u32, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for u64 {
    type Output = Quantity<u64, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for u128 {
    type Output = Quantity<u128, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for usize {
    type Output = Quantity<usize, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for f32 {
    type Output = Quantity<f32, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
impl Mul<UnitPetawattsMul> for f64 {
    type Output = Quantity<f64, UnitPetawatts>;
    fn mul(self, _: UnitPetawattsMul) -> Self::Output {
        Quantity::new(self, UnitPetawatts)
    }
}
pub struct UnitTerawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerawatts {
    #[inline]
    fn clone(&self) -> UnitTerawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerawatts {
    #[inline]
    fn eq(&self, other: &UnitTerawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerawatts {
    fn default() -> Self {
        UnitTerawatts
    }
}
impl Add<UnitTerawatts> for UnitTerawatts {
    type Output = UnitTerawatts;
    #[inline]
    fn add(self, _: UnitTerawatts) -> Self::Output {
        UnitTerawatts
    }
}
impl AddAssign<UnitTerawatts> for UnitTerawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitTerawatts) {}
}
impl Sub<UnitTerawatts> for UnitTerawatts {
    type Output = UnitTerawatts;
    #[inline]
    fn sub(self, _: UnitTerawatts) -> Self::Output {
        UnitTerawatts
    }
}
impl SubAssign<UnitTerawatts> for UnitTerawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerawatts) {}
}
pub struct UnitTerawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerawattsMul {
    #[inline]
    fn clone(&self) -> UnitTerawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerawattsMul {
    #[inline]
    fn eq(&self, other: &UnitTerawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerawattsMul> for i8 {
    type Output = Quantity<i8, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for i16 {
    type Output = Quantity<i16, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for i32 {
    type Output = Quantity<i32, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for i64 {
    type Output = Quantity<i64, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for i128 {
    type Output = Quantity<i128, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for isize {
    type Output = Quantity<isize, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for u8 {
    type Output = Quantity<u8, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for u16 {
    type Output = Quantity<u16, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for u32 {
    type Output = Quantity<u32, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for u64 {
    type Output = Quantity<u64, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for u128 {
    type Output = Quantity<u128, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for usize {
    type Output = Quantity<usize, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for f32 {
    type Output = Quantity<f32, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
impl Mul<UnitTerawattsMul> for f64 {
    type Output = Quantity<f64, UnitTerawatts>;
    fn mul(self, _: UnitTerawattsMul) -> Self::Output {
        Quantity::new(self, UnitTerawatts)
    }
}
pub struct UnitGigawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigawatts {
    #[inline]
    fn clone(&self) -> UnitGigawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigawatts {
    #[inline]
    fn eq(&self, other: &UnitGigawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigawatts {
    fn default() -> Self {
        UnitGigawatts
    }
}
impl Add<UnitGigawatts> for UnitGigawatts {
    type Output = UnitGigawatts;
    #[inline]
    fn add(self, _: UnitGigawatts) -> Self::Output {
        UnitGigawatts
    }
}
impl AddAssign<UnitGigawatts> for UnitGigawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitGigawatts) {}
}
impl Sub<UnitGigawatts> for UnitGigawatts {
    type Output = UnitGigawatts;
    #[inline]
    fn sub(self, _: UnitGigawatts) -> Self::Output {
        UnitGigawatts
    }
}
impl SubAssign<UnitGigawatts> for UnitGigawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigawatts) {}
}
pub struct UnitGigawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigawattsMul {
    #[inline]
    fn clone(&self) -> UnitGigawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigawattsMul {
    #[inline]
    fn eq(&self, other: &UnitGigawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigawattsMul> for i8 {
    type Output = Quantity<i8, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for i16 {
    type Output = Quantity<i16, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for i32 {
    type Output = Quantity<i32, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for i64 {
    type Output = Quantity<i64, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for i128 {
    type Output = Quantity<i128, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for isize {
    type Output = Quantity<isize, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for u8 {
    type Output = Quantity<u8, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for u16 {
    type Output = Quantity<u16, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for u32 {
    type Output = Quantity<u32, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for u64 {
    type Output = Quantity<u64, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for u128 {
    type Output = Quantity<u128, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for usize {
    type Output = Quantity<usize, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for f32 {
    type Output = Quantity<f32, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
impl Mul<UnitGigawattsMul> for f64 {
    type Output = Quantity<f64, UnitGigawatts>;
    fn mul(self, _: UnitGigawattsMul) -> Self::Output {
        Quantity::new(self, UnitGigawatts)
    }
}
pub struct UnitMegawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegawatts {
    #[inline]
    fn clone(&self) -> UnitMegawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegawatts {
    #[inline]
    fn eq(&self, other: &UnitMegawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegawatts {
    fn default() -> Self {
        UnitMegawatts
    }
}
impl Add<UnitMegawatts> for UnitMegawatts {
    type Output = UnitMegawatts;
    #[inline]
    fn add(self, _: UnitMegawatts) -> Self::Output {
        UnitMegawatts
    }
}
impl AddAssign<UnitMegawatts> for UnitMegawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitMegawatts) {}
}
impl Sub<UnitMegawatts> for UnitMegawatts {
    type Output = UnitMegawatts;
    #[inline]
    fn sub(self, _: UnitMegawatts) -> Self::Output {
        UnitMegawatts
    }
}
impl SubAssign<UnitMegawatts> for UnitMegawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegawatts) {}
}
pub struct UnitMegawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegawattsMul {
    #[inline]
    fn clone(&self) -> UnitMegawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegawattsMul {
    #[inline]
    fn eq(&self, other: &UnitMegawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegawattsMul> for i8 {
    type Output = Quantity<i8, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for i16 {
    type Output = Quantity<i16, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for i32 {
    type Output = Quantity<i32, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for i64 {
    type Output = Quantity<i64, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for i128 {
    type Output = Quantity<i128, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for isize {
    type Output = Quantity<isize, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for u8 {
    type Output = Quantity<u8, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for u16 {
    type Output = Quantity<u16, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for u32 {
    type Output = Quantity<u32, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for u64 {
    type Output = Quantity<u64, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for u128 {
    type Output = Quantity<u128, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for usize {
    type Output = Quantity<usize, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for f32 {
    type Output = Quantity<f32, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
impl Mul<UnitMegawattsMul> for f64 {
    type Output = Quantity<f64, UnitMegawatts>;
    fn mul(self, _: UnitMegawattsMul) -> Self::Output {
        Quantity::new(self, UnitMegawatts)
    }
}
pub struct UnitKilowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilowatts {
    #[inline]
    fn clone(&self) -> UnitKilowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilowatts {
    #[inline]
    fn eq(&self, other: &UnitKilowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilowatts {
    fn default() -> Self {
        UnitKilowatts
    }
}
impl Add<UnitKilowatts> for UnitKilowatts {
    type Output = UnitKilowatts;
    #[inline]
    fn add(self, _: UnitKilowatts) -> Self::Output {
        UnitKilowatts
    }
}
impl AddAssign<UnitKilowatts> for UnitKilowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitKilowatts) {}
}
impl Sub<UnitKilowatts> for UnitKilowatts {
    type Output = UnitKilowatts;
    #[inline]
    fn sub(self, _: UnitKilowatts) -> Self::Output {
        UnitKilowatts
    }
}
impl SubAssign<UnitKilowatts> for UnitKilowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilowatts) {}
}
pub struct UnitKilowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilowattsMul {
    #[inline]
    fn clone(&self) -> UnitKilowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilowattsMul {
    #[inline]
    fn eq(&self, other: &UnitKilowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilowattsMul> for i8 {
    type Output = Quantity<i8, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for i16 {
    type Output = Quantity<i16, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for i32 {
    type Output = Quantity<i32, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for i64 {
    type Output = Quantity<i64, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for i128 {
    type Output = Quantity<i128, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for isize {
    type Output = Quantity<isize, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for u8 {
    type Output = Quantity<u8, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for u16 {
    type Output = Quantity<u16, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for u32 {
    type Output = Quantity<u32, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for u64 {
    type Output = Quantity<u64, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for u128 {
    type Output = Quantity<u128, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for usize {
    type Output = Quantity<usize, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for f32 {
    type Output = Quantity<f32, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
impl Mul<UnitKilowattsMul> for f64 {
    type Output = Quantity<f64, UnitKilowatts>;
    fn mul(self, _: UnitKilowattsMul) -> Self::Output {
        Quantity::new(self, UnitKilowatts)
    }
}
pub struct UnitHectowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectowatts {
    #[inline]
    fn clone(&self) -> UnitHectowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectowatts {
    #[inline]
    fn eq(&self, other: &UnitHectowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectowatts {
    fn default() -> Self {
        UnitHectowatts
    }
}
impl Add<UnitHectowatts> for UnitHectowatts {
    type Output = UnitHectowatts;
    #[inline]
    fn add(self, _: UnitHectowatts) -> Self::Output {
        UnitHectowatts
    }
}
impl AddAssign<UnitHectowatts> for UnitHectowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitHectowatts) {}
}
impl Sub<UnitHectowatts> for UnitHectowatts {
    type Output = UnitHectowatts;
    #[inline]
    fn sub(self, _: UnitHectowatts) -> Self::Output {
        UnitHectowatts
    }
}
impl SubAssign<UnitHectowatts> for UnitHectowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectowatts) {}
}
pub struct UnitHectowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectowattsMul {
    #[inline]
    fn clone(&self) -> UnitHectowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectowattsMul {
    #[inline]
    fn eq(&self, other: &UnitHectowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectowattsMul> for i8 {
    type Output = Quantity<i8, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for i16 {
    type Output = Quantity<i16, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for i32 {
    type Output = Quantity<i32, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for i64 {
    type Output = Quantity<i64, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for i128 {
    type Output = Quantity<i128, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for isize {
    type Output = Quantity<isize, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for u8 {
    type Output = Quantity<u8, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for u16 {
    type Output = Quantity<u16, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for u32 {
    type Output = Quantity<u32, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for u64 {
    type Output = Quantity<u64, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for u128 {
    type Output = Quantity<u128, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for usize {
    type Output = Quantity<usize, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for f32 {
    type Output = Quantity<f32, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
impl Mul<UnitHectowattsMul> for f64 {
    type Output = Quantity<f64, UnitHectowatts>;
    fn mul(self, _: UnitHectowattsMul) -> Self::Output {
        Quantity::new(self, UnitHectowatts)
    }
}
pub struct UnitDecawatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecawatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecawatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecawatts {
    #[inline]
    fn clone(&self) -> UnitDecawatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecawatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecawatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecawatts {
    #[inline]
    fn eq(&self, other: &UnitDecawatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecawatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecawatts {
    fn default() -> Self {
        UnitDecawatts
    }
}
impl Add<UnitDecawatts> for UnitDecawatts {
    type Output = UnitDecawatts;
    #[inline]
    fn add(self, _: UnitDecawatts) -> Self::Output {
        UnitDecawatts
    }
}
impl AddAssign<UnitDecawatts> for UnitDecawatts {
    #[inline]
    fn add_assign(&mut self, _: UnitDecawatts) {}
}
impl Sub<UnitDecawatts> for UnitDecawatts {
    type Output = UnitDecawatts;
    #[inline]
    fn sub(self, _: UnitDecawatts) -> Self::Output {
        UnitDecawatts
    }
}
impl SubAssign<UnitDecawatts> for UnitDecawatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecawatts) {}
}
pub struct UnitDecawattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecawattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecawattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecawattsMul {
    #[inline]
    fn clone(&self) -> UnitDecawattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecawattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecawattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecawattsMul {
    #[inline]
    fn eq(&self, other: &UnitDecawattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecawattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecawattsMul> for i8 {
    type Output = Quantity<i8, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for i16 {
    type Output = Quantity<i16, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for i32 {
    type Output = Quantity<i32, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for i64 {
    type Output = Quantity<i64, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for i128 {
    type Output = Quantity<i128, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for isize {
    type Output = Quantity<isize, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for u8 {
    type Output = Quantity<u8, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for u16 {
    type Output = Quantity<u16, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for u32 {
    type Output = Quantity<u32, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for u64 {
    type Output = Quantity<u64, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for u128 {
    type Output = Quantity<u128, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for usize {
    type Output = Quantity<usize, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for f32 {
    type Output = Quantity<f32, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
impl Mul<UnitDecawattsMul> for f64 {
    type Output = Quantity<f64, UnitDecawatts>;
    fn mul(self, _: UnitDecawattsMul) -> Self::Output {
        Quantity::new(self, UnitDecawatts)
    }
}
pub struct UnitDeciwatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciwatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciwatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciwatts {
    #[inline]
    fn clone(&self) -> UnitDeciwatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciwatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciwatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciwatts {
    #[inline]
    fn eq(&self, other: &UnitDeciwatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciwatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciwatts {
    fn default() -> Self {
        UnitDeciwatts
    }
}
impl Add<UnitDeciwatts> for UnitDeciwatts {
    type Output = UnitDeciwatts;
    #[inline]
    fn add(self, _: UnitDeciwatts) -> Self::Output {
        UnitDeciwatts
    }
}
impl AddAssign<UnitDeciwatts> for UnitDeciwatts {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciwatts) {}
}
impl Sub<UnitDeciwatts> for UnitDeciwatts {
    type Output = UnitDeciwatts;
    #[inline]
    fn sub(self, _: UnitDeciwatts) -> Self::Output {
        UnitDeciwatts
    }
}
impl SubAssign<UnitDeciwatts> for UnitDeciwatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciwatts) {}
}
pub struct UnitDeciwattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciwattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciwattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciwattsMul {
    #[inline]
    fn clone(&self) -> UnitDeciwattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciwattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciwattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciwattsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciwattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciwattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciwattsMul> for i8 {
    type Output = Quantity<i8, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for i16 {
    type Output = Quantity<i16, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for i32 {
    type Output = Quantity<i32, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for i64 {
    type Output = Quantity<i64, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for i128 {
    type Output = Quantity<i128, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for isize {
    type Output = Quantity<isize, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for u8 {
    type Output = Quantity<u8, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for u16 {
    type Output = Quantity<u16, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for u32 {
    type Output = Quantity<u32, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for u64 {
    type Output = Quantity<u64, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for u128 {
    type Output = Quantity<u128, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for usize {
    type Output = Quantity<usize, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for f32 {
    type Output = Quantity<f32, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
impl Mul<UnitDeciwattsMul> for f64 {
    type Output = Quantity<f64, UnitDeciwatts>;
    fn mul(self, _: UnitDeciwattsMul) -> Self::Output {
        Quantity::new(self, UnitDeciwatts)
    }
}
pub struct UnitCentiwatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiwatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiwatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiwatts {
    #[inline]
    fn clone(&self) -> UnitCentiwatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiwatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiwatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiwatts {
    #[inline]
    fn eq(&self, other: &UnitCentiwatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiwatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiwatts {
    fn default() -> Self {
        UnitCentiwatts
    }
}
impl Add<UnitCentiwatts> for UnitCentiwatts {
    type Output = UnitCentiwatts;
    #[inline]
    fn add(self, _: UnitCentiwatts) -> Self::Output {
        UnitCentiwatts
    }
}
impl AddAssign<UnitCentiwatts> for UnitCentiwatts {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiwatts) {}
}
impl Sub<UnitCentiwatts> for UnitCentiwatts {
    type Output = UnitCentiwatts;
    #[inline]
    fn sub(self, _: UnitCentiwatts) -> Self::Output {
        UnitCentiwatts
    }
}
impl SubAssign<UnitCentiwatts> for UnitCentiwatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiwatts) {}
}
pub struct UnitCentiwattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiwattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiwattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiwattsMul {
    #[inline]
    fn clone(&self) -> UnitCentiwattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiwattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiwattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiwattsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiwattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiwattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiwattsMul> for i8 {
    type Output = Quantity<i8, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for i16 {
    type Output = Quantity<i16, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for i32 {
    type Output = Quantity<i32, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for i64 {
    type Output = Quantity<i64, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for i128 {
    type Output = Quantity<i128, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for isize {
    type Output = Quantity<isize, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for u8 {
    type Output = Quantity<u8, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for u16 {
    type Output = Quantity<u16, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for u32 {
    type Output = Quantity<u32, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for u64 {
    type Output = Quantity<u64, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for u128 {
    type Output = Quantity<u128, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for usize {
    type Output = Quantity<usize, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for f32 {
    type Output = Quantity<f32, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
impl Mul<UnitCentiwattsMul> for f64 {
    type Output = Quantity<f64, UnitCentiwatts>;
    fn mul(self, _: UnitCentiwattsMul) -> Self::Output {
        Quantity::new(self, UnitCentiwatts)
    }
}
pub struct UnitMilliwatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliwatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliwatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliwatts {
    #[inline]
    fn clone(&self) -> UnitMilliwatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliwatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliwatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliwatts {
    #[inline]
    fn eq(&self, other: &UnitMilliwatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliwatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliwatts {
    fn default() -> Self {
        UnitMilliwatts
    }
}
impl Add<UnitMilliwatts> for UnitMilliwatts {
    type Output = UnitMilliwatts;
    #[inline]
    fn add(self, _: UnitMilliwatts) -> Self::Output {
        UnitMilliwatts
    }
}
impl AddAssign<UnitMilliwatts> for UnitMilliwatts {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliwatts) {}
}
impl Sub<UnitMilliwatts> for UnitMilliwatts {
    type Output = UnitMilliwatts;
    #[inline]
    fn sub(self, _: UnitMilliwatts) -> Self::Output {
        UnitMilliwatts
    }
}
impl SubAssign<UnitMilliwatts> for UnitMilliwatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliwatts) {}
}
pub struct UnitMilliwattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliwattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliwattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliwattsMul {
    #[inline]
    fn clone(&self) -> UnitMilliwattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliwattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliwattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliwattsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliwattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliwattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliwattsMul> for i8 {
    type Output = Quantity<i8, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for i16 {
    type Output = Quantity<i16, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for i32 {
    type Output = Quantity<i32, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for i64 {
    type Output = Quantity<i64, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for i128 {
    type Output = Quantity<i128, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for isize {
    type Output = Quantity<isize, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for u8 {
    type Output = Quantity<u8, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for u16 {
    type Output = Quantity<u16, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for u32 {
    type Output = Quantity<u32, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for u64 {
    type Output = Quantity<u64, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for u128 {
    type Output = Quantity<u128, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for usize {
    type Output = Quantity<usize, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for f32 {
    type Output = Quantity<f32, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
impl Mul<UnitMilliwattsMul> for f64 {
    type Output = Quantity<f64, UnitMilliwatts>;
    fn mul(self, _: UnitMilliwattsMul) -> Self::Output {
        Quantity::new(self, UnitMilliwatts)
    }
}
pub struct UnitMicrowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrowatts {
    #[inline]
    fn clone(&self) -> UnitMicrowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrowatts {
    #[inline]
    fn eq(&self, other: &UnitMicrowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrowatts {
    fn default() -> Self {
        UnitMicrowatts
    }
}
impl Add<UnitMicrowatts> for UnitMicrowatts {
    type Output = UnitMicrowatts;
    #[inline]
    fn add(self, _: UnitMicrowatts) -> Self::Output {
        UnitMicrowatts
    }
}
impl AddAssign<UnitMicrowatts> for UnitMicrowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrowatts) {}
}
impl Sub<UnitMicrowatts> for UnitMicrowatts {
    type Output = UnitMicrowatts;
    #[inline]
    fn sub(self, _: UnitMicrowatts) -> Self::Output {
        UnitMicrowatts
    }
}
impl SubAssign<UnitMicrowatts> for UnitMicrowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrowatts) {}
}
pub struct UnitMicrowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrowattsMul {
    #[inline]
    fn clone(&self) -> UnitMicrowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrowattsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrowattsMul> for i8 {
    type Output = Quantity<i8, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for i16 {
    type Output = Quantity<i16, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for i32 {
    type Output = Quantity<i32, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for i64 {
    type Output = Quantity<i64, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for i128 {
    type Output = Quantity<i128, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for isize {
    type Output = Quantity<isize, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for u8 {
    type Output = Quantity<u8, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for u16 {
    type Output = Quantity<u16, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for u32 {
    type Output = Quantity<u32, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for u64 {
    type Output = Quantity<u64, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for u128 {
    type Output = Quantity<u128, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for usize {
    type Output = Quantity<usize, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for f32 {
    type Output = Quantity<f32, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
impl Mul<UnitMicrowattsMul> for f64 {
    type Output = Quantity<f64, UnitMicrowatts>;
    fn mul(self, _: UnitMicrowattsMul) -> Self::Output {
        Quantity::new(self, UnitMicrowatts)
    }
}
pub struct UnitNanowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanowatts {
    #[inline]
    fn clone(&self) -> UnitNanowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanowatts {
    #[inline]
    fn eq(&self, other: &UnitNanowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanowatts {
    fn default() -> Self {
        UnitNanowatts
    }
}
impl Add<UnitNanowatts> for UnitNanowatts {
    type Output = UnitNanowatts;
    #[inline]
    fn add(self, _: UnitNanowatts) -> Self::Output {
        UnitNanowatts
    }
}
impl AddAssign<UnitNanowatts> for UnitNanowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitNanowatts) {}
}
impl Sub<UnitNanowatts> for UnitNanowatts {
    type Output = UnitNanowatts;
    #[inline]
    fn sub(self, _: UnitNanowatts) -> Self::Output {
        UnitNanowatts
    }
}
impl SubAssign<UnitNanowatts> for UnitNanowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanowatts) {}
}
pub struct UnitNanowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanowattsMul {
    #[inline]
    fn clone(&self) -> UnitNanowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanowattsMul {
    #[inline]
    fn eq(&self, other: &UnitNanowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanowattsMul> for i8 {
    type Output = Quantity<i8, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for i16 {
    type Output = Quantity<i16, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for i32 {
    type Output = Quantity<i32, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for i64 {
    type Output = Quantity<i64, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for i128 {
    type Output = Quantity<i128, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for isize {
    type Output = Quantity<isize, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for u8 {
    type Output = Quantity<u8, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for u16 {
    type Output = Quantity<u16, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for u32 {
    type Output = Quantity<u32, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for u64 {
    type Output = Quantity<u64, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for u128 {
    type Output = Quantity<u128, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for usize {
    type Output = Quantity<usize, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for f32 {
    type Output = Quantity<f32, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
impl Mul<UnitNanowattsMul> for f64 {
    type Output = Quantity<f64, UnitNanowatts>;
    fn mul(self, _: UnitNanowattsMul) -> Self::Output {
        Quantity::new(self, UnitNanowatts)
    }
}
pub struct UnitPicowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicowatts {
    #[inline]
    fn clone(&self) -> UnitPicowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicowatts {
    #[inline]
    fn eq(&self, other: &UnitPicowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicowatts {
    fn default() -> Self {
        UnitPicowatts
    }
}
impl Add<UnitPicowatts> for UnitPicowatts {
    type Output = UnitPicowatts;
    #[inline]
    fn add(self, _: UnitPicowatts) -> Self::Output {
        UnitPicowatts
    }
}
impl AddAssign<UnitPicowatts> for UnitPicowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitPicowatts) {}
}
impl Sub<UnitPicowatts> for UnitPicowatts {
    type Output = UnitPicowatts;
    #[inline]
    fn sub(self, _: UnitPicowatts) -> Self::Output {
        UnitPicowatts
    }
}
impl SubAssign<UnitPicowatts> for UnitPicowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicowatts) {}
}
pub struct UnitPicowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicowattsMul {
    #[inline]
    fn clone(&self) -> UnitPicowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicowattsMul {
    #[inline]
    fn eq(&self, other: &UnitPicowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicowattsMul> for i8 {
    type Output = Quantity<i8, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for i16 {
    type Output = Quantity<i16, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for i32 {
    type Output = Quantity<i32, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for i64 {
    type Output = Quantity<i64, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for i128 {
    type Output = Quantity<i128, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for isize {
    type Output = Quantity<isize, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for u8 {
    type Output = Quantity<u8, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for u16 {
    type Output = Quantity<u16, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for u32 {
    type Output = Quantity<u32, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for u64 {
    type Output = Quantity<u64, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for u128 {
    type Output = Quantity<u128, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for usize {
    type Output = Quantity<usize, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for f32 {
    type Output = Quantity<f32, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
impl Mul<UnitPicowattsMul> for f64 {
    type Output = Quantity<f64, UnitPicowatts>;
    fn mul(self, _: UnitPicowattsMul) -> Self::Output {
        Quantity::new(self, UnitPicowatts)
    }
}
pub struct UnitFemtowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtowatts {
    #[inline]
    fn clone(&self) -> UnitFemtowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtowatts {
    #[inline]
    fn eq(&self, other: &UnitFemtowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtowatts {
    fn default() -> Self {
        UnitFemtowatts
    }
}
impl Add<UnitFemtowatts> for UnitFemtowatts {
    type Output = UnitFemtowatts;
    #[inline]
    fn add(self, _: UnitFemtowatts) -> Self::Output {
        UnitFemtowatts
    }
}
impl AddAssign<UnitFemtowatts> for UnitFemtowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtowatts) {}
}
impl Sub<UnitFemtowatts> for UnitFemtowatts {
    type Output = UnitFemtowatts;
    #[inline]
    fn sub(self, _: UnitFemtowatts) -> Self::Output {
        UnitFemtowatts
    }
}
impl SubAssign<UnitFemtowatts> for UnitFemtowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtowatts) {}
}
pub struct UnitFemtowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtowattsMul {
    #[inline]
    fn clone(&self) -> UnitFemtowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtowattsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtowattsMul> for i8 {
    type Output = Quantity<i8, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for i16 {
    type Output = Quantity<i16, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for i32 {
    type Output = Quantity<i32, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for i64 {
    type Output = Quantity<i64, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for i128 {
    type Output = Quantity<i128, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for isize {
    type Output = Quantity<isize, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for u8 {
    type Output = Quantity<u8, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for u16 {
    type Output = Quantity<u16, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for u32 {
    type Output = Quantity<u32, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for u64 {
    type Output = Quantity<u64, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for u128 {
    type Output = Quantity<u128, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for usize {
    type Output = Quantity<usize, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for f32 {
    type Output = Quantity<f32, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
impl Mul<UnitFemtowattsMul> for f64 {
    type Output = Quantity<f64, UnitFemtowatts>;
    fn mul(self, _: UnitFemtowattsMul) -> Self::Output {
        Quantity::new(self, UnitFemtowatts)
    }
}
pub struct UnitAttowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttowatts {
    #[inline]
    fn clone(&self) -> UnitAttowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttowatts {
    #[inline]
    fn eq(&self, other: &UnitAttowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttowatts {
    fn default() -> Self {
        UnitAttowatts
    }
}
impl Add<UnitAttowatts> for UnitAttowatts {
    type Output = UnitAttowatts;
    #[inline]
    fn add(self, _: UnitAttowatts) -> Self::Output {
        UnitAttowatts
    }
}
impl AddAssign<UnitAttowatts> for UnitAttowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitAttowatts) {}
}
impl Sub<UnitAttowatts> for UnitAttowatts {
    type Output = UnitAttowatts;
    #[inline]
    fn sub(self, _: UnitAttowatts) -> Self::Output {
        UnitAttowatts
    }
}
impl SubAssign<UnitAttowatts> for UnitAttowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttowatts) {}
}
pub struct UnitAttowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttowattsMul {
    #[inline]
    fn clone(&self) -> UnitAttowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttowattsMul {
    #[inline]
    fn eq(&self, other: &UnitAttowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttowattsMul> for i8 {
    type Output = Quantity<i8, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for i16 {
    type Output = Quantity<i16, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for i32 {
    type Output = Quantity<i32, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for i64 {
    type Output = Quantity<i64, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for i128 {
    type Output = Quantity<i128, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for isize {
    type Output = Quantity<isize, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for u8 {
    type Output = Quantity<u8, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for u16 {
    type Output = Quantity<u16, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for u32 {
    type Output = Quantity<u32, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for u64 {
    type Output = Quantity<u64, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for u128 {
    type Output = Quantity<u128, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for usize {
    type Output = Quantity<usize, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for f32 {
    type Output = Quantity<f32, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
impl Mul<UnitAttowattsMul> for f64 {
    type Output = Quantity<f64, UnitAttowatts>;
    fn mul(self, _: UnitAttowattsMul) -> Self::Output {
        Quantity::new(self, UnitAttowatts)
    }
}
pub struct UnitZeptowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptowatts {
    #[inline]
    fn clone(&self) -> UnitZeptowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptowatts {
    #[inline]
    fn eq(&self, other: &UnitZeptowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptowatts {
    fn default() -> Self {
        UnitZeptowatts
    }
}
impl Add<UnitZeptowatts> for UnitZeptowatts {
    type Output = UnitZeptowatts;
    #[inline]
    fn add(self, _: UnitZeptowatts) -> Self::Output {
        UnitZeptowatts
    }
}
impl AddAssign<UnitZeptowatts> for UnitZeptowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptowatts) {}
}
impl Sub<UnitZeptowatts> for UnitZeptowatts {
    type Output = UnitZeptowatts;
    #[inline]
    fn sub(self, _: UnitZeptowatts) -> Self::Output {
        UnitZeptowatts
    }
}
impl SubAssign<UnitZeptowatts> for UnitZeptowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptowatts) {}
}
pub struct UnitZeptowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptowattsMul {
    #[inline]
    fn clone(&self) -> UnitZeptowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptowattsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptowattsMul> for i8 {
    type Output = Quantity<i8, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for i16 {
    type Output = Quantity<i16, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for i32 {
    type Output = Quantity<i32, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for i64 {
    type Output = Quantity<i64, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for i128 {
    type Output = Quantity<i128, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for isize {
    type Output = Quantity<isize, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for u8 {
    type Output = Quantity<u8, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for u16 {
    type Output = Quantity<u16, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for u32 {
    type Output = Quantity<u32, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for u64 {
    type Output = Quantity<u64, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for u128 {
    type Output = Quantity<u128, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for usize {
    type Output = Quantity<usize, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for f32 {
    type Output = Quantity<f32, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
impl Mul<UnitZeptowattsMul> for f64 {
    type Output = Quantity<f64, UnitZeptowatts>;
    fn mul(self, _: UnitZeptowattsMul) -> Self::Output {
        Quantity::new(self, UnitZeptowatts)
    }
}
pub struct UnitYoctowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctowatts {
    #[inline]
    fn clone(&self) -> UnitYoctowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctowatts {
    #[inline]
    fn eq(&self, other: &UnitYoctowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctowatts {
    fn default() -> Self {
        UnitYoctowatts
    }
}
impl Add<UnitYoctowatts> for UnitYoctowatts {
    type Output = UnitYoctowatts;
    #[inline]
    fn add(self, _: UnitYoctowatts) -> Self::Output {
        UnitYoctowatts
    }
}
impl AddAssign<UnitYoctowatts> for UnitYoctowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctowatts) {}
}
impl Sub<UnitYoctowatts> for UnitYoctowatts {
    type Output = UnitYoctowatts;
    #[inline]
    fn sub(self, _: UnitYoctowatts) -> Self::Output {
        UnitYoctowatts
    }
}
impl SubAssign<UnitYoctowatts> for UnitYoctowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctowatts) {}
}
pub struct UnitYoctowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctowattsMul {
    #[inline]
    fn clone(&self) -> UnitYoctowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctowattsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctowattsMul> for i8 {
    type Output = Quantity<i8, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for i16 {
    type Output = Quantity<i16, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for i32 {
    type Output = Quantity<i32, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for i64 {
    type Output = Quantity<i64, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for i128 {
    type Output = Quantity<i128, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for isize {
    type Output = Quantity<isize, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for u8 {
    type Output = Quantity<u8, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for u16 {
    type Output = Quantity<u16, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for u32 {
    type Output = Quantity<u32, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for u64 {
    type Output = Quantity<u64, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for u128 {
    type Output = Quantity<u128, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for usize {
    type Output = Quantity<usize, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for f32 {
    type Output = Quantity<f32, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
impl Mul<UnitYoctowattsMul> for f64 {
    type Output = Quantity<f64, UnitYoctowatts>;
    fn mul(self, _: UnitYoctowattsMul) -> Self::Output {
        Quantity::new(self, UnitYoctowatts)
    }
}
pub struct UnitRontowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontowatts {
    #[inline]
    fn clone(&self) -> UnitRontowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontowatts {
    #[inline]
    fn eq(&self, other: &UnitRontowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontowatts {
    fn default() -> Self {
        UnitRontowatts
    }
}
impl Add<UnitRontowatts> for UnitRontowatts {
    type Output = UnitRontowatts;
    #[inline]
    fn add(self, _: UnitRontowatts) -> Self::Output {
        UnitRontowatts
    }
}
impl AddAssign<UnitRontowatts> for UnitRontowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitRontowatts) {}
}
impl Sub<UnitRontowatts> for UnitRontowatts {
    type Output = UnitRontowatts;
    #[inline]
    fn sub(self, _: UnitRontowatts) -> Self::Output {
        UnitRontowatts
    }
}
impl SubAssign<UnitRontowatts> for UnitRontowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontowatts) {}
}
pub struct UnitRontowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontowattsMul {
    #[inline]
    fn clone(&self) -> UnitRontowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontowattsMul {
    #[inline]
    fn eq(&self, other: &UnitRontowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontowattsMul> for i8 {
    type Output = Quantity<i8, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for i16 {
    type Output = Quantity<i16, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for i32 {
    type Output = Quantity<i32, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for i64 {
    type Output = Quantity<i64, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for i128 {
    type Output = Quantity<i128, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for isize {
    type Output = Quantity<isize, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for u8 {
    type Output = Quantity<u8, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for u16 {
    type Output = Quantity<u16, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for u32 {
    type Output = Quantity<u32, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for u64 {
    type Output = Quantity<u64, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for u128 {
    type Output = Quantity<u128, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for usize {
    type Output = Quantity<usize, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for f32 {
    type Output = Quantity<f32, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
impl Mul<UnitRontowattsMul> for f64 {
    type Output = Quantity<f64, UnitRontowatts>;
    fn mul(self, _: UnitRontowattsMul) -> Self::Output {
        Quantity::new(self, UnitRontowatts)
    }
}
pub struct UnitQuectowatts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectowatts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectowatts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectowatts {
    #[inline]
    fn clone(&self) -> UnitQuectowatts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectowatts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectowatts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectowatts {
    #[inline]
    fn eq(&self, other: &UnitQuectowatts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectowatts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectowatts {
    fn default() -> Self {
        UnitQuectowatts
    }
}
impl Add<UnitQuectowatts> for UnitQuectowatts {
    type Output = UnitQuectowatts;
    #[inline]
    fn add(self, _: UnitQuectowatts) -> Self::Output {
        UnitQuectowatts
    }
}
impl AddAssign<UnitQuectowatts> for UnitQuectowatts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectowatts) {}
}
impl Sub<UnitQuectowatts> for UnitQuectowatts {
    type Output = UnitQuectowatts;
    #[inline]
    fn sub(self, _: UnitQuectowatts) -> Self::Output {
        UnitQuectowatts
    }
}
impl SubAssign<UnitQuectowatts> for UnitQuectowatts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectowatts) {}
}
pub struct UnitQuectowattsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectowattsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectowattsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectowattsMul {
    #[inline]
    fn clone(&self) -> UnitQuectowattsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectowattsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectowattsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectowattsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectowattsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectowattsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectowattsMul> for i8 {
    type Output = Quantity<i8, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for i16 {
    type Output = Quantity<i16, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for i32 {
    type Output = Quantity<i32, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for i64 {
    type Output = Quantity<i64, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for i128 {
    type Output = Quantity<i128, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for isize {
    type Output = Quantity<isize, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for u8 {
    type Output = Quantity<u8, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for u16 {
    type Output = Quantity<u16, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for u32 {
    type Output = Quantity<u32, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for u64 {
    type Output = Quantity<u64, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for u128 {
    type Output = Quantity<u128, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for usize {
    type Output = Quantity<usize, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for f32 {
    type Output = Quantity<f32, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
impl Mul<UnitQuectowattsMul> for f64 {
    type Output = Quantity<f64, UnitQuectowatts>;
    fn mul(self, _: UnitQuectowattsMul) -> Self::Output {
        Quantity::new(self, UnitQuectowatts)
    }
}
pub type Watts<T> = Quantity<T, UnitWatts>;
#[allow(non_upper_case_globals)]
pub static Watts: UnitWattsMul = UnitWattsMul;
pub type Quettawatts<T> = Quantity<T, UnitQuettawatts>;
#[allow(non_upper_case_globals)]
pub static Quettawatts: UnitQuettawattsMul = UnitQuettawattsMul;
pub type Ronnawatts<T> = Quantity<T, UnitRonnawatts>;
#[allow(non_upper_case_globals)]
pub static Ronnawatts: UnitRonnawattsMul = UnitRonnawattsMul;
pub type Yottawatts<T> = Quantity<T, UnitYottawatts>;
#[allow(non_upper_case_globals)]
pub static Yottawatts: UnitYottawattsMul = UnitYottawattsMul;
pub type Zettawatts<T> = Quantity<T, UnitZettawatts>;
#[allow(non_upper_case_globals)]
pub static Zettawatts: UnitZettawattsMul = UnitZettawattsMul;
pub type Exawatts<T> = Quantity<T, UnitExawatts>;
#[allow(non_upper_case_globals)]
pub static Exawatts: UnitExawattsMul = UnitExawattsMul;
pub type Petawatts<T> = Quantity<T, UnitPetawatts>;
#[allow(non_upper_case_globals)]
pub static Petawatts: UnitPetawattsMul = UnitPetawattsMul;
pub type Terawatts<T> = Quantity<T, UnitTerawatts>;
#[allow(non_upper_case_globals)]
pub static Terawatts: UnitTerawattsMul = UnitTerawattsMul;
pub type Gigawatts<T> = Quantity<T, UnitGigawatts>;
#[allow(non_upper_case_globals)]
pub static Gigawatts: UnitGigawattsMul = UnitGigawattsMul;
pub type Megawatts<T> = Quantity<T, UnitMegawatts>;
#[allow(non_upper_case_globals)]
pub static Megawatts: UnitMegawattsMul = UnitMegawattsMul;
pub type Kilowatts<T> = Quantity<T, UnitKilowatts>;
#[allow(non_upper_case_globals)]
pub static Kilowatts: UnitKilowattsMul = UnitKilowattsMul;
pub type Hectowatts<T> = Quantity<T, UnitHectowatts>;
#[allow(non_upper_case_globals)]
pub static Hectowatts: UnitHectowattsMul = UnitHectowattsMul;
pub type Decawatts<T> = Quantity<T, UnitDecawatts>;
#[allow(non_upper_case_globals)]
pub static Decawatts: UnitDecawattsMul = UnitDecawattsMul;
pub type Deciwatts<T> = Quantity<T, UnitDeciwatts>;
#[allow(non_upper_case_globals)]
pub static Deciwatts: UnitDeciwattsMul = UnitDeciwattsMul;
pub type Centiwatts<T> = Quantity<T, UnitCentiwatts>;
#[allow(non_upper_case_globals)]
pub static Centiwatts: UnitCentiwattsMul = UnitCentiwattsMul;
pub type Milliwatts<T> = Quantity<T, UnitMilliwatts>;
#[allow(non_upper_case_globals)]
pub static Milliwatts: UnitMilliwattsMul = UnitMilliwattsMul;
pub type Microwatts<T> = Quantity<T, UnitMicrowatts>;
#[allow(non_upper_case_globals)]
pub static Microwatts: UnitMicrowattsMul = UnitMicrowattsMul;
pub type Nanowatts<T> = Quantity<T, UnitNanowatts>;
#[allow(non_upper_case_globals)]
pub static Nanowatts: UnitNanowattsMul = UnitNanowattsMul;
pub type Picowatts<T> = Quantity<T, UnitPicowatts>;
#[allow(non_upper_case_globals)]
pub static Picowatts: UnitPicowattsMul = UnitPicowattsMul;
pub type Femtowatts<T> = Quantity<T, UnitFemtowatts>;
#[allow(non_upper_case_globals)]
pub static Femtowatts: UnitFemtowattsMul = UnitFemtowattsMul;
pub type Attowatts<T> = Quantity<T, UnitAttowatts>;
#[allow(non_upper_case_globals)]
pub static Attowatts: UnitAttowattsMul = UnitAttowattsMul;
pub type Zeptowatts<T> = Quantity<T, UnitZeptowatts>;
#[allow(non_upper_case_globals)]
pub static Zeptowatts: UnitZeptowattsMul = UnitZeptowattsMul;
pub type Yoctowatts<T> = Quantity<T, UnitYoctowatts>;
#[allow(non_upper_case_globals)]
pub static Yoctowatts: UnitYoctowattsMul = UnitYoctowattsMul;
pub type Rontowatts<T> = Quantity<T, UnitRontowatts>;
#[allow(non_upper_case_globals)]
pub static Rontowatts: UnitRontowattsMul = UnitRontowattsMul;
pub type Quectowatts<T> = Quantity<T, UnitQuectowatts>;
#[allow(non_upper_case_globals)]
pub static Quectowatts: UnitQuectowattsMul = UnitQuectowattsMul;
pub struct UnitCoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCoulombs {
    #[inline]
    fn clone(&self) -> UnitCoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCoulombs {
    #[inline]
    fn eq(&self, other: &UnitCoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCoulombs {
    fn default() -> Self {
        UnitCoulombs
    }
}
impl Add<UnitCoulombs> for UnitCoulombs {
    type Output = UnitCoulombs;
    #[inline]
    fn add(self, _: UnitCoulombs) -> Self::Output {
        UnitCoulombs
    }
}
impl AddAssign<UnitCoulombs> for UnitCoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitCoulombs) {}
}
impl Sub<UnitCoulombs> for UnitCoulombs {
    type Output = UnitCoulombs;
    #[inline]
    fn sub(self, _: UnitCoulombs) -> Self::Output {
        UnitCoulombs
    }
}
impl SubAssign<UnitCoulombs> for UnitCoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitCoulombs) {}
}
pub struct UnitCoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCoulombsMul {
    #[inline]
    fn clone(&self) -> UnitCoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitCoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCoulombsMul> for i8 {
    type Output = Quantity<i8, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for i16 {
    type Output = Quantity<i16, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for i32 {
    type Output = Quantity<i32, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for i64 {
    type Output = Quantity<i64, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for i128 {
    type Output = Quantity<i128, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for isize {
    type Output = Quantity<isize, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for u8 {
    type Output = Quantity<u8, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for u16 {
    type Output = Quantity<u16, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for u32 {
    type Output = Quantity<u32, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for u64 {
    type Output = Quantity<u64, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for u128 {
    type Output = Quantity<u128, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for usize {
    type Output = Quantity<usize, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for f32 {
    type Output = Quantity<f32, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
impl Mul<UnitCoulombsMul> for f64 {
    type Output = Quantity<f64, UnitCoulombs>;
    fn mul(self, _: UnitCoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCoulombs)
    }
}
pub struct UnitQuettacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacoulombs {
    #[inline]
    fn clone(&self) -> UnitQuettacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacoulombs {
    #[inline]
    fn eq(&self, other: &UnitQuettacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettacoulombs {
    fn default() -> Self {
        UnitQuettacoulombs
    }
}
impl Add<UnitQuettacoulombs> for UnitQuettacoulombs {
    type Output = UnitQuettacoulombs;
    #[inline]
    fn add(self, _: UnitQuettacoulombs) -> Self::Output {
        UnitQuettacoulombs
    }
}
impl AddAssign<UnitQuettacoulombs> for UnitQuettacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettacoulombs) {}
}
impl Sub<UnitQuettacoulombs> for UnitQuettacoulombs {
    type Output = UnitQuettacoulombs;
    #[inline]
    fn sub(self, _: UnitQuettacoulombs) -> Self::Output {
        UnitQuettacoulombs
    }
}
impl SubAssign<UnitQuettacoulombs> for UnitQuettacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettacoulombs) {}
}
pub struct UnitQuettacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitQuettacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for isize {
    type Output = Quantity<isize, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for usize {
    type Output = Quantity<usize, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
impl Mul<UnitQuettacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitQuettacoulombs>;
    fn mul(self, _: UnitQuettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuettacoulombs)
    }
}
pub struct UnitRonnacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacoulombs {
    #[inline]
    fn clone(&self) -> UnitRonnacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacoulombs {
    #[inline]
    fn eq(&self, other: &UnitRonnacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnacoulombs {
    fn default() -> Self {
        UnitRonnacoulombs
    }
}
impl Add<UnitRonnacoulombs> for UnitRonnacoulombs {
    type Output = UnitRonnacoulombs;
    #[inline]
    fn add(self, _: UnitRonnacoulombs) -> Self::Output {
        UnitRonnacoulombs
    }
}
impl AddAssign<UnitRonnacoulombs> for UnitRonnacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnacoulombs) {}
}
impl Sub<UnitRonnacoulombs> for UnitRonnacoulombs {
    type Output = UnitRonnacoulombs;
    #[inline]
    fn sub(self, _: UnitRonnacoulombs) -> Self::Output {
        UnitRonnacoulombs
    }
}
impl SubAssign<UnitRonnacoulombs> for UnitRonnacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnacoulombs) {}
}
pub struct UnitRonnacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitRonnacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for isize {
    type Output = Quantity<isize, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for usize {
    type Output = Quantity<usize, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
impl Mul<UnitRonnacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitRonnacoulombs>;
    fn mul(self, _: UnitRonnacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRonnacoulombs)
    }
}
pub struct UnitYottacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacoulombs {
    #[inline]
    fn clone(&self) -> UnitYottacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacoulombs {
    #[inline]
    fn eq(&self, other: &UnitYottacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottacoulombs {
    fn default() -> Self {
        UnitYottacoulombs
    }
}
impl Add<UnitYottacoulombs> for UnitYottacoulombs {
    type Output = UnitYottacoulombs;
    #[inline]
    fn add(self, _: UnitYottacoulombs) -> Self::Output {
        UnitYottacoulombs
    }
}
impl AddAssign<UnitYottacoulombs> for UnitYottacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitYottacoulombs) {}
}
impl Sub<UnitYottacoulombs> for UnitYottacoulombs {
    type Output = UnitYottacoulombs;
    #[inline]
    fn sub(self, _: UnitYottacoulombs) -> Self::Output {
        UnitYottacoulombs
    }
}
impl SubAssign<UnitYottacoulombs> for UnitYottacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottacoulombs) {}
}
pub struct UnitYottacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitYottacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitYottacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for isize {
    type Output = Quantity<isize, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for usize {
    type Output = Quantity<usize, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
impl Mul<UnitYottacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitYottacoulombs>;
    fn mul(self, _: UnitYottacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYottacoulombs)
    }
}
pub struct UnitZettacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacoulombs {
    #[inline]
    fn clone(&self) -> UnitZettacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacoulombs {
    #[inline]
    fn eq(&self, other: &UnitZettacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettacoulombs {
    fn default() -> Self {
        UnitZettacoulombs
    }
}
impl Add<UnitZettacoulombs> for UnitZettacoulombs {
    type Output = UnitZettacoulombs;
    #[inline]
    fn add(self, _: UnitZettacoulombs) -> Self::Output {
        UnitZettacoulombs
    }
}
impl AddAssign<UnitZettacoulombs> for UnitZettacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitZettacoulombs) {}
}
impl Sub<UnitZettacoulombs> for UnitZettacoulombs {
    type Output = UnitZettacoulombs;
    #[inline]
    fn sub(self, _: UnitZettacoulombs) -> Self::Output {
        UnitZettacoulombs
    }
}
impl SubAssign<UnitZettacoulombs> for UnitZettacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettacoulombs) {}
}
pub struct UnitZettacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitZettacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitZettacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for isize {
    type Output = Quantity<isize, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for usize {
    type Output = Quantity<usize, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
impl Mul<UnitZettacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitZettacoulombs>;
    fn mul(self, _: UnitZettacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZettacoulombs)
    }
}
pub struct UnitExacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacoulombs {
    #[inline]
    fn clone(&self) -> UnitExacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacoulombs {
    #[inline]
    fn eq(&self, other: &UnitExacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExacoulombs {
    fn default() -> Self {
        UnitExacoulombs
    }
}
impl Add<UnitExacoulombs> for UnitExacoulombs {
    type Output = UnitExacoulombs;
    #[inline]
    fn add(self, _: UnitExacoulombs) -> Self::Output {
        UnitExacoulombs
    }
}
impl AddAssign<UnitExacoulombs> for UnitExacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitExacoulombs) {}
}
impl Sub<UnitExacoulombs> for UnitExacoulombs {
    type Output = UnitExacoulombs;
    #[inline]
    fn sub(self, _: UnitExacoulombs) -> Self::Output {
        UnitExacoulombs
    }
}
impl SubAssign<UnitExacoulombs> for UnitExacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitExacoulombs) {}
}
pub struct UnitExacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitExacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitExacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for isize {
    type Output = Quantity<isize, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for usize {
    type Output = Quantity<usize, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
impl Mul<UnitExacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitExacoulombs>;
    fn mul(self, _: UnitExacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitExacoulombs)
    }
}
pub struct UnitPetacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacoulombs {
    #[inline]
    fn clone(&self) -> UnitPetacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacoulombs {
    #[inline]
    fn eq(&self, other: &UnitPetacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetacoulombs {
    fn default() -> Self {
        UnitPetacoulombs
    }
}
impl Add<UnitPetacoulombs> for UnitPetacoulombs {
    type Output = UnitPetacoulombs;
    #[inline]
    fn add(self, _: UnitPetacoulombs) -> Self::Output {
        UnitPetacoulombs
    }
}
impl AddAssign<UnitPetacoulombs> for UnitPetacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitPetacoulombs) {}
}
impl Sub<UnitPetacoulombs> for UnitPetacoulombs {
    type Output = UnitPetacoulombs;
    #[inline]
    fn sub(self, _: UnitPetacoulombs) -> Self::Output {
        UnitPetacoulombs
    }
}
impl SubAssign<UnitPetacoulombs> for UnitPetacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetacoulombs) {}
}
pub struct UnitPetacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitPetacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitPetacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for isize {
    type Output = Quantity<isize, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for usize {
    type Output = Quantity<usize, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
impl Mul<UnitPetacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitPetacoulombs>;
    fn mul(self, _: UnitPetacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPetacoulombs)
    }
}
pub struct UnitTeracoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracoulombs {
    #[inline]
    fn clone(&self) -> UnitTeracoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracoulombs {
    #[inline]
    fn eq(&self, other: &UnitTeracoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeracoulombs {
    fn default() -> Self {
        UnitTeracoulombs
    }
}
impl Add<UnitTeracoulombs> for UnitTeracoulombs {
    type Output = UnitTeracoulombs;
    #[inline]
    fn add(self, _: UnitTeracoulombs) -> Self::Output {
        UnitTeracoulombs
    }
}
impl AddAssign<UnitTeracoulombs> for UnitTeracoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitTeracoulombs) {}
}
impl Sub<UnitTeracoulombs> for UnitTeracoulombs {
    type Output = UnitTeracoulombs;
    #[inline]
    fn sub(self, _: UnitTeracoulombs) -> Self::Output {
        UnitTeracoulombs
    }
}
impl SubAssign<UnitTeracoulombs> for UnitTeracoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeracoulombs) {}
}
pub struct UnitTeracoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracoulombsMul {
    #[inline]
    fn clone(&self) -> UnitTeracoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitTeracoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeracoulombsMul> for i8 {
    type Output = Quantity<i8, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for i16 {
    type Output = Quantity<i16, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for i32 {
    type Output = Quantity<i32, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for i64 {
    type Output = Quantity<i64, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for i128 {
    type Output = Quantity<i128, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for isize {
    type Output = Quantity<isize, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for u8 {
    type Output = Quantity<u8, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for u16 {
    type Output = Quantity<u16, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for u32 {
    type Output = Quantity<u32, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for u64 {
    type Output = Quantity<u64, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for u128 {
    type Output = Quantity<u128, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for usize {
    type Output = Quantity<usize, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for f32 {
    type Output = Quantity<f32, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
impl Mul<UnitTeracoulombsMul> for f64 {
    type Output = Quantity<f64, UnitTeracoulombs>;
    fn mul(self, _: UnitTeracoulombsMul) -> Self::Output {
        Quantity::new(self, UnitTeracoulombs)
    }
}
pub struct UnitGigacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacoulombs {
    #[inline]
    fn clone(&self) -> UnitGigacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacoulombs {
    #[inline]
    fn eq(&self, other: &UnitGigacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigacoulombs {
    fn default() -> Self {
        UnitGigacoulombs
    }
}
impl Add<UnitGigacoulombs> for UnitGigacoulombs {
    type Output = UnitGigacoulombs;
    #[inline]
    fn add(self, _: UnitGigacoulombs) -> Self::Output {
        UnitGigacoulombs
    }
}
impl AddAssign<UnitGigacoulombs> for UnitGigacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitGigacoulombs) {}
}
impl Sub<UnitGigacoulombs> for UnitGigacoulombs {
    type Output = UnitGigacoulombs;
    #[inline]
    fn sub(self, _: UnitGigacoulombs) -> Self::Output {
        UnitGigacoulombs
    }
}
impl SubAssign<UnitGigacoulombs> for UnitGigacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigacoulombs) {}
}
pub struct UnitGigacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitGigacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitGigacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for isize {
    type Output = Quantity<isize, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for usize {
    type Output = Quantity<usize, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
impl Mul<UnitGigacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitGigacoulombs>;
    fn mul(self, _: UnitGigacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitGigacoulombs)
    }
}
pub struct UnitMegacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacoulombs {
    #[inline]
    fn clone(&self) -> UnitMegacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacoulombs {
    #[inline]
    fn eq(&self, other: &UnitMegacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegacoulombs {
    fn default() -> Self {
        UnitMegacoulombs
    }
}
impl Add<UnitMegacoulombs> for UnitMegacoulombs {
    type Output = UnitMegacoulombs;
    #[inline]
    fn add(self, _: UnitMegacoulombs) -> Self::Output {
        UnitMegacoulombs
    }
}
impl AddAssign<UnitMegacoulombs> for UnitMegacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitMegacoulombs) {}
}
impl Sub<UnitMegacoulombs> for UnitMegacoulombs {
    type Output = UnitMegacoulombs;
    #[inline]
    fn sub(self, _: UnitMegacoulombs) -> Self::Output {
        UnitMegacoulombs
    }
}
impl SubAssign<UnitMegacoulombs> for UnitMegacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegacoulombs) {}
}
pub struct UnitMegacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitMegacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitMegacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for isize {
    type Output = Quantity<isize, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for usize {
    type Output = Quantity<usize, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
impl Mul<UnitMegacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitMegacoulombs>;
    fn mul(self, _: UnitMegacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMegacoulombs)
    }
}
pub struct UnitKilocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocoulombs {
    #[inline]
    fn clone(&self) -> UnitKilocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocoulombs {
    #[inline]
    fn eq(&self, other: &UnitKilocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilocoulombs {
    fn default() -> Self {
        UnitKilocoulombs
    }
}
impl Add<UnitKilocoulombs> for UnitKilocoulombs {
    type Output = UnitKilocoulombs;
    #[inline]
    fn add(self, _: UnitKilocoulombs) -> Self::Output {
        UnitKilocoulombs
    }
}
impl AddAssign<UnitKilocoulombs> for UnitKilocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitKilocoulombs) {}
}
impl Sub<UnitKilocoulombs> for UnitKilocoulombs {
    type Output = UnitKilocoulombs;
    #[inline]
    fn sub(self, _: UnitKilocoulombs) -> Self::Output {
        UnitKilocoulombs
    }
}
impl SubAssign<UnitKilocoulombs> for UnitKilocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilocoulombs) {}
}
pub struct UnitKilocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitKilocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitKilocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for isize {
    type Output = Quantity<isize, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for usize {
    type Output = Quantity<usize, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
impl Mul<UnitKilocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitKilocoulombs>;
    fn mul(self, _: UnitKilocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitKilocoulombs)
    }
}
pub struct UnitHectocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocoulombs {
    #[inline]
    fn clone(&self) -> UnitHectocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocoulombs {
    #[inline]
    fn eq(&self, other: &UnitHectocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectocoulombs {
    fn default() -> Self {
        UnitHectocoulombs
    }
}
impl Add<UnitHectocoulombs> for UnitHectocoulombs {
    type Output = UnitHectocoulombs;
    #[inline]
    fn add(self, _: UnitHectocoulombs) -> Self::Output {
        UnitHectocoulombs
    }
}
impl AddAssign<UnitHectocoulombs> for UnitHectocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitHectocoulombs) {}
}
impl Sub<UnitHectocoulombs> for UnitHectocoulombs {
    type Output = UnitHectocoulombs;
    #[inline]
    fn sub(self, _: UnitHectocoulombs) -> Self::Output {
        UnitHectocoulombs
    }
}
impl SubAssign<UnitHectocoulombs> for UnitHectocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectocoulombs) {}
}
pub struct UnitHectocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitHectocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitHectocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for isize {
    type Output = Quantity<isize, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for usize {
    type Output = Quantity<usize, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
impl Mul<UnitHectocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitHectocoulombs>;
    fn mul(self, _: UnitHectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitHectocoulombs)
    }
}
pub struct UnitDecacoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacoulombs {
    #[inline]
    fn clone(&self) -> UnitDecacoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacoulombs {
    #[inline]
    fn eq(&self, other: &UnitDecacoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecacoulombs {
    fn default() -> Self {
        UnitDecacoulombs
    }
}
impl Add<UnitDecacoulombs> for UnitDecacoulombs {
    type Output = UnitDecacoulombs;
    #[inline]
    fn add(self, _: UnitDecacoulombs) -> Self::Output {
        UnitDecacoulombs
    }
}
impl AddAssign<UnitDecacoulombs> for UnitDecacoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitDecacoulombs) {}
}
impl Sub<UnitDecacoulombs> for UnitDecacoulombs {
    type Output = UnitDecacoulombs;
    #[inline]
    fn sub(self, _: UnitDecacoulombs) -> Self::Output {
        UnitDecacoulombs
    }
}
impl SubAssign<UnitDecacoulombs> for UnitDecacoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecacoulombs) {}
}
pub struct UnitDecacoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacoulombsMul {
    #[inline]
    fn clone(&self) -> UnitDecacoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitDecacoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecacoulombsMul> for i8 {
    type Output = Quantity<i8, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for i16 {
    type Output = Quantity<i16, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for i32 {
    type Output = Quantity<i32, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for i64 {
    type Output = Quantity<i64, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for i128 {
    type Output = Quantity<i128, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for isize {
    type Output = Quantity<isize, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for u8 {
    type Output = Quantity<u8, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for u16 {
    type Output = Quantity<u16, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for u32 {
    type Output = Quantity<u32, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for u64 {
    type Output = Quantity<u64, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for u128 {
    type Output = Quantity<u128, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for usize {
    type Output = Quantity<usize, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for f32 {
    type Output = Quantity<f32, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
impl Mul<UnitDecacoulombsMul> for f64 {
    type Output = Quantity<f64, UnitDecacoulombs>;
    fn mul(self, _: UnitDecacoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecacoulombs)
    }
}
pub struct UnitDecicoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicoulombs {
    #[inline]
    fn clone(&self) -> UnitDecicoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicoulombs {
    #[inline]
    fn eq(&self, other: &UnitDecicoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecicoulombs {
    fn default() -> Self {
        UnitDecicoulombs
    }
}
impl Add<UnitDecicoulombs> for UnitDecicoulombs {
    type Output = UnitDecicoulombs;
    #[inline]
    fn add(self, _: UnitDecicoulombs) -> Self::Output {
        UnitDecicoulombs
    }
}
impl AddAssign<UnitDecicoulombs> for UnitDecicoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitDecicoulombs) {}
}
impl Sub<UnitDecicoulombs> for UnitDecicoulombs {
    type Output = UnitDecicoulombs;
    #[inline]
    fn sub(self, _: UnitDecicoulombs) -> Self::Output {
        UnitDecicoulombs
    }
}
impl SubAssign<UnitDecicoulombs> for UnitDecicoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecicoulombs) {}
}
pub struct UnitDecicoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicoulombsMul {
    #[inline]
    fn clone(&self) -> UnitDecicoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitDecicoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecicoulombsMul> for i8 {
    type Output = Quantity<i8, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for i16 {
    type Output = Quantity<i16, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for i32 {
    type Output = Quantity<i32, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for i64 {
    type Output = Quantity<i64, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for i128 {
    type Output = Quantity<i128, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for isize {
    type Output = Quantity<isize, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for u8 {
    type Output = Quantity<u8, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for u16 {
    type Output = Quantity<u16, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for u32 {
    type Output = Quantity<u32, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for u64 {
    type Output = Quantity<u64, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for u128 {
    type Output = Quantity<u128, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for usize {
    type Output = Quantity<usize, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for f32 {
    type Output = Quantity<f32, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
impl Mul<UnitDecicoulombsMul> for f64 {
    type Output = Quantity<f64, UnitDecicoulombs>;
    fn mul(self, _: UnitDecicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitDecicoulombs)
    }
}
pub struct UnitCenticoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticoulombs {
    #[inline]
    fn clone(&self) -> UnitCenticoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticoulombs {
    #[inline]
    fn eq(&self, other: &UnitCenticoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCenticoulombs {
    fn default() -> Self {
        UnitCenticoulombs
    }
}
impl Add<UnitCenticoulombs> for UnitCenticoulombs {
    type Output = UnitCenticoulombs;
    #[inline]
    fn add(self, _: UnitCenticoulombs) -> Self::Output {
        UnitCenticoulombs
    }
}
impl AddAssign<UnitCenticoulombs> for UnitCenticoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitCenticoulombs) {}
}
impl Sub<UnitCenticoulombs> for UnitCenticoulombs {
    type Output = UnitCenticoulombs;
    #[inline]
    fn sub(self, _: UnitCenticoulombs) -> Self::Output {
        UnitCenticoulombs
    }
}
impl SubAssign<UnitCenticoulombs> for UnitCenticoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitCenticoulombs) {}
}
pub struct UnitCenticoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticoulombsMul {
    #[inline]
    fn clone(&self) -> UnitCenticoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitCenticoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCenticoulombsMul> for i8 {
    type Output = Quantity<i8, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for i16 {
    type Output = Quantity<i16, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for i32 {
    type Output = Quantity<i32, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for i64 {
    type Output = Quantity<i64, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for i128 {
    type Output = Quantity<i128, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for isize {
    type Output = Quantity<isize, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for u8 {
    type Output = Quantity<u8, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for u16 {
    type Output = Quantity<u16, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for u32 {
    type Output = Quantity<u32, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for u64 {
    type Output = Quantity<u64, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for u128 {
    type Output = Quantity<u128, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for usize {
    type Output = Quantity<usize, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for f32 {
    type Output = Quantity<f32, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
impl Mul<UnitCenticoulombsMul> for f64 {
    type Output = Quantity<f64, UnitCenticoulombs>;
    fn mul(self, _: UnitCenticoulombsMul) -> Self::Output {
        Quantity::new(self, UnitCenticoulombs)
    }
}
pub struct UnitMillicoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicoulombs {
    #[inline]
    fn clone(&self) -> UnitMillicoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicoulombs {
    #[inline]
    fn eq(&self, other: &UnitMillicoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillicoulombs {
    fn default() -> Self {
        UnitMillicoulombs
    }
}
impl Add<UnitMillicoulombs> for UnitMillicoulombs {
    type Output = UnitMillicoulombs;
    #[inline]
    fn add(self, _: UnitMillicoulombs) -> Self::Output {
        UnitMillicoulombs
    }
}
impl AddAssign<UnitMillicoulombs> for UnitMillicoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitMillicoulombs) {}
}
impl Sub<UnitMillicoulombs> for UnitMillicoulombs {
    type Output = UnitMillicoulombs;
    #[inline]
    fn sub(self, _: UnitMillicoulombs) -> Self::Output {
        UnitMillicoulombs
    }
}
impl SubAssign<UnitMillicoulombs> for UnitMillicoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillicoulombs) {}
}
pub struct UnitMillicoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicoulombsMul {
    #[inline]
    fn clone(&self) -> UnitMillicoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitMillicoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillicoulombsMul> for i8 {
    type Output = Quantity<i8, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for i16 {
    type Output = Quantity<i16, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for i32 {
    type Output = Quantity<i32, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for i64 {
    type Output = Quantity<i64, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for i128 {
    type Output = Quantity<i128, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for isize {
    type Output = Quantity<isize, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for u8 {
    type Output = Quantity<u8, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for u16 {
    type Output = Quantity<u16, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for u32 {
    type Output = Quantity<u32, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for u64 {
    type Output = Quantity<u64, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for u128 {
    type Output = Quantity<u128, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for usize {
    type Output = Quantity<usize, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for f32 {
    type Output = Quantity<f32, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
impl Mul<UnitMillicoulombsMul> for f64 {
    type Output = Quantity<f64, UnitMillicoulombs>;
    fn mul(self, _: UnitMillicoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMillicoulombs)
    }
}
pub struct UnitMicrocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocoulombs {
    #[inline]
    fn clone(&self) -> UnitMicrocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocoulombs {
    #[inline]
    fn eq(&self, other: &UnitMicrocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrocoulombs {
    fn default() -> Self {
        UnitMicrocoulombs
    }
}
impl Add<UnitMicrocoulombs> for UnitMicrocoulombs {
    type Output = UnitMicrocoulombs;
    #[inline]
    fn add(self, _: UnitMicrocoulombs) -> Self::Output {
        UnitMicrocoulombs
    }
}
impl AddAssign<UnitMicrocoulombs> for UnitMicrocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrocoulombs) {}
}
impl Sub<UnitMicrocoulombs> for UnitMicrocoulombs {
    type Output = UnitMicrocoulombs;
    #[inline]
    fn sub(self, _: UnitMicrocoulombs) -> Self::Output {
        UnitMicrocoulombs
    }
}
impl SubAssign<UnitMicrocoulombs> for UnitMicrocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrocoulombs) {}
}
pub struct UnitMicrocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitMicrocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for isize {
    type Output = Quantity<isize, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for usize {
    type Output = Quantity<usize, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
impl Mul<UnitMicrocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitMicrocoulombs>;
    fn mul(self, _: UnitMicrocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitMicrocoulombs)
    }
}
pub struct UnitNanocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocoulombs {
    #[inline]
    fn clone(&self) -> UnitNanocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocoulombs {
    #[inline]
    fn eq(&self, other: &UnitNanocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanocoulombs {
    fn default() -> Self {
        UnitNanocoulombs
    }
}
impl Add<UnitNanocoulombs> for UnitNanocoulombs {
    type Output = UnitNanocoulombs;
    #[inline]
    fn add(self, _: UnitNanocoulombs) -> Self::Output {
        UnitNanocoulombs
    }
}
impl AddAssign<UnitNanocoulombs> for UnitNanocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitNanocoulombs) {}
}
impl Sub<UnitNanocoulombs> for UnitNanocoulombs {
    type Output = UnitNanocoulombs;
    #[inline]
    fn sub(self, _: UnitNanocoulombs) -> Self::Output {
        UnitNanocoulombs
    }
}
impl SubAssign<UnitNanocoulombs> for UnitNanocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanocoulombs) {}
}
pub struct UnitNanocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitNanocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitNanocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for isize {
    type Output = Quantity<isize, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for usize {
    type Output = Quantity<usize, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
impl Mul<UnitNanocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitNanocoulombs>;
    fn mul(self, _: UnitNanocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitNanocoulombs)
    }
}
pub struct UnitPicocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocoulombs {
    #[inline]
    fn clone(&self) -> UnitPicocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocoulombs {
    #[inline]
    fn eq(&self, other: &UnitPicocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicocoulombs {
    fn default() -> Self {
        UnitPicocoulombs
    }
}
impl Add<UnitPicocoulombs> for UnitPicocoulombs {
    type Output = UnitPicocoulombs;
    #[inline]
    fn add(self, _: UnitPicocoulombs) -> Self::Output {
        UnitPicocoulombs
    }
}
impl AddAssign<UnitPicocoulombs> for UnitPicocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitPicocoulombs) {}
}
impl Sub<UnitPicocoulombs> for UnitPicocoulombs {
    type Output = UnitPicocoulombs;
    #[inline]
    fn sub(self, _: UnitPicocoulombs) -> Self::Output {
        UnitPicocoulombs
    }
}
impl SubAssign<UnitPicocoulombs> for UnitPicocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicocoulombs) {}
}
pub struct UnitPicocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitPicocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitPicocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for isize {
    type Output = Quantity<isize, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for usize {
    type Output = Quantity<usize, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
impl Mul<UnitPicocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitPicocoulombs>;
    fn mul(self, _: UnitPicocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitPicocoulombs)
    }
}
pub struct UnitFemtocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocoulombs {
    #[inline]
    fn clone(&self) -> UnitFemtocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocoulombs {
    #[inline]
    fn eq(&self, other: &UnitFemtocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtocoulombs {
    fn default() -> Self {
        UnitFemtocoulombs
    }
}
impl Add<UnitFemtocoulombs> for UnitFemtocoulombs {
    type Output = UnitFemtocoulombs;
    #[inline]
    fn add(self, _: UnitFemtocoulombs) -> Self::Output {
        UnitFemtocoulombs
    }
}
impl AddAssign<UnitFemtocoulombs> for UnitFemtocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtocoulombs) {}
}
impl Sub<UnitFemtocoulombs> for UnitFemtocoulombs {
    type Output = UnitFemtocoulombs;
    #[inline]
    fn sub(self, _: UnitFemtocoulombs) -> Self::Output {
        UnitFemtocoulombs
    }
}
impl SubAssign<UnitFemtocoulombs> for UnitFemtocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtocoulombs) {}
}
pub struct UnitFemtocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitFemtocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for isize {
    type Output = Quantity<isize, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for usize {
    type Output = Quantity<usize, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
impl Mul<UnitFemtocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitFemtocoulombs>;
    fn mul(self, _: UnitFemtocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitFemtocoulombs)
    }
}
pub struct UnitAttocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocoulombs {
    #[inline]
    fn clone(&self) -> UnitAttocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocoulombs {
    #[inline]
    fn eq(&self, other: &UnitAttocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttocoulombs {
    fn default() -> Self {
        UnitAttocoulombs
    }
}
impl Add<UnitAttocoulombs> for UnitAttocoulombs {
    type Output = UnitAttocoulombs;
    #[inline]
    fn add(self, _: UnitAttocoulombs) -> Self::Output {
        UnitAttocoulombs
    }
}
impl AddAssign<UnitAttocoulombs> for UnitAttocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitAttocoulombs) {}
}
impl Sub<UnitAttocoulombs> for UnitAttocoulombs {
    type Output = UnitAttocoulombs;
    #[inline]
    fn sub(self, _: UnitAttocoulombs) -> Self::Output {
        UnitAttocoulombs
    }
}
impl SubAssign<UnitAttocoulombs> for UnitAttocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttocoulombs) {}
}
pub struct UnitAttocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitAttocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitAttocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for isize {
    type Output = Quantity<isize, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for usize {
    type Output = Quantity<usize, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
impl Mul<UnitAttocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitAttocoulombs>;
    fn mul(self, _: UnitAttocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitAttocoulombs)
    }
}
pub struct UnitZeptocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocoulombs {
    #[inline]
    fn clone(&self) -> UnitZeptocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocoulombs {
    #[inline]
    fn eq(&self, other: &UnitZeptocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptocoulombs {
    fn default() -> Self {
        UnitZeptocoulombs
    }
}
impl Add<UnitZeptocoulombs> for UnitZeptocoulombs {
    type Output = UnitZeptocoulombs;
    #[inline]
    fn add(self, _: UnitZeptocoulombs) -> Self::Output {
        UnitZeptocoulombs
    }
}
impl AddAssign<UnitZeptocoulombs> for UnitZeptocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptocoulombs) {}
}
impl Sub<UnitZeptocoulombs> for UnitZeptocoulombs {
    type Output = UnitZeptocoulombs;
    #[inline]
    fn sub(self, _: UnitZeptocoulombs) -> Self::Output {
        UnitZeptocoulombs
    }
}
impl SubAssign<UnitZeptocoulombs> for UnitZeptocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptocoulombs) {}
}
pub struct UnitZeptocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitZeptocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for isize {
    type Output = Quantity<isize, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for usize {
    type Output = Quantity<usize, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
impl Mul<UnitZeptocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitZeptocoulombs>;
    fn mul(self, _: UnitZeptocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitZeptocoulombs)
    }
}
pub struct UnitYoctocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocoulombs {
    #[inline]
    fn clone(&self) -> UnitYoctocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocoulombs {
    #[inline]
    fn eq(&self, other: &UnitYoctocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctocoulombs {
    fn default() -> Self {
        UnitYoctocoulombs
    }
}
impl Add<UnitYoctocoulombs> for UnitYoctocoulombs {
    type Output = UnitYoctocoulombs;
    #[inline]
    fn add(self, _: UnitYoctocoulombs) -> Self::Output {
        UnitYoctocoulombs
    }
}
impl AddAssign<UnitYoctocoulombs> for UnitYoctocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctocoulombs) {}
}
impl Sub<UnitYoctocoulombs> for UnitYoctocoulombs {
    type Output = UnitYoctocoulombs;
    #[inline]
    fn sub(self, _: UnitYoctocoulombs) -> Self::Output {
        UnitYoctocoulombs
    }
}
impl SubAssign<UnitYoctocoulombs> for UnitYoctocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctocoulombs) {}
}
pub struct UnitYoctocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitYoctocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for isize {
    type Output = Quantity<isize, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for usize {
    type Output = Quantity<usize, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
impl Mul<UnitYoctocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitYoctocoulombs>;
    fn mul(self, _: UnitYoctocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitYoctocoulombs)
    }
}
pub struct UnitRontocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocoulombs {
    #[inline]
    fn clone(&self) -> UnitRontocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocoulombs {
    #[inline]
    fn eq(&self, other: &UnitRontocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontocoulombs {
    fn default() -> Self {
        UnitRontocoulombs
    }
}
impl Add<UnitRontocoulombs> for UnitRontocoulombs {
    type Output = UnitRontocoulombs;
    #[inline]
    fn add(self, _: UnitRontocoulombs) -> Self::Output {
        UnitRontocoulombs
    }
}
impl AddAssign<UnitRontocoulombs> for UnitRontocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitRontocoulombs) {}
}
impl Sub<UnitRontocoulombs> for UnitRontocoulombs {
    type Output = UnitRontocoulombs;
    #[inline]
    fn sub(self, _: UnitRontocoulombs) -> Self::Output {
        UnitRontocoulombs
    }
}
impl SubAssign<UnitRontocoulombs> for UnitRontocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontocoulombs) {}
}
pub struct UnitRontocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitRontocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitRontocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for isize {
    type Output = Quantity<isize, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for usize {
    type Output = Quantity<usize, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
impl Mul<UnitRontocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitRontocoulombs>;
    fn mul(self, _: UnitRontocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitRontocoulombs)
    }
}
pub struct UnitQuectocoulombs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocoulombs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocoulombs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocoulombs {
    #[inline]
    fn clone(&self) -> UnitQuectocoulombs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocoulombs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocoulombs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocoulombs {
    #[inline]
    fn eq(&self, other: &UnitQuectocoulombs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocoulombs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectocoulombs {
    fn default() -> Self {
        UnitQuectocoulombs
    }
}
impl Add<UnitQuectocoulombs> for UnitQuectocoulombs {
    type Output = UnitQuectocoulombs;
    #[inline]
    fn add(self, _: UnitQuectocoulombs) -> Self::Output {
        UnitQuectocoulombs
    }
}
impl AddAssign<UnitQuectocoulombs> for UnitQuectocoulombs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectocoulombs) {}
}
impl Sub<UnitQuectocoulombs> for UnitQuectocoulombs {
    type Output = UnitQuectocoulombs;
    #[inline]
    fn sub(self, _: UnitQuectocoulombs) -> Self::Output {
        UnitQuectocoulombs
    }
}
impl SubAssign<UnitQuectocoulombs> for UnitQuectocoulombs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectocoulombs) {}
}
pub struct UnitQuectocoulombsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocoulombsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocoulombsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocoulombsMul {
    #[inline]
    fn clone(&self) -> UnitQuectocoulombsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocoulombsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocoulombsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocoulombsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectocoulombsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocoulombsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectocoulombsMul> for i8 {
    type Output = Quantity<i8, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for i16 {
    type Output = Quantity<i16, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for i32 {
    type Output = Quantity<i32, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for i64 {
    type Output = Quantity<i64, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for i128 {
    type Output = Quantity<i128, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for isize {
    type Output = Quantity<isize, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for u8 {
    type Output = Quantity<u8, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for u16 {
    type Output = Quantity<u16, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for u32 {
    type Output = Quantity<u32, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for u64 {
    type Output = Quantity<u64, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for u128 {
    type Output = Quantity<u128, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for usize {
    type Output = Quantity<usize, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for f32 {
    type Output = Quantity<f32, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
impl Mul<UnitQuectocoulombsMul> for f64 {
    type Output = Quantity<f64, UnitQuectocoulombs>;
    fn mul(self, _: UnitQuectocoulombsMul) -> Self::Output {
        Quantity::new(self, UnitQuectocoulombs)
    }
}
pub type Coulombs<T> = Quantity<T, UnitCoulombs>;
#[allow(non_upper_case_globals)]
pub static Coulombs: UnitCoulombsMul = UnitCoulombsMul;
pub type Quettacoulombs<T> = Quantity<T, UnitQuettacoulombs>;
#[allow(non_upper_case_globals)]
pub static Quettacoulombs: UnitQuettacoulombsMul = UnitQuettacoulombsMul;
pub type Ronnacoulombs<T> = Quantity<T, UnitRonnacoulombs>;
#[allow(non_upper_case_globals)]
pub static Ronnacoulombs: UnitRonnacoulombsMul = UnitRonnacoulombsMul;
pub type Yottacoulombs<T> = Quantity<T, UnitYottacoulombs>;
#[allow(non_upper_case_globals)]
pub static Yottacoulombs: UnitYottacoulombsMul = UnitYottacoulombsMul;
pub type Zettacoulombs<T> = Quantity<T, UnitZettacoulombs>;
#[allow(non_upper_case_globals)]
pub static Zettacoulombs: UnitZettacoulombsMul = UnitZettacoulombsMul;
pub type Exacoulombs<T> = Quantity<T, UnitExacoulombs>;
#[allow(non_upper_case_globals)]
pub static Exacoulombs: UnitExacoulombsMul = UnitExacoulombsMul;
pub type Petacoulombs<T> = Quantity<T, UnitPetacoulombs>;
#[allow(non_upper_case_globals)]
pub static Petacoulombs: UnitPetacoulombsMul = UnitPetacoulombsMul;
pub type Teracoulombs<T> = Quantity<T, UnitTeracoulombs>;
#[allow(non_upper_case_globals)]
pub static Teracoulombs: UnitTeracoulombsMul = UnitTeracoulombsMul;
pub type Gigacoulombs<T> = Quantity<T, UnitGigacoulombs>;
#[allow(non_upper_case_globals)]
pub static Gigacoulombs: UnitGigacoulombsMul = UnitGigacoulombsMul;
pub type Megacoulombs<T> = Quantity<T, UnitMegacoulombs>;
#[allow(non_upper_case_globals)]
pub static Megacoulombs: UnitMegacoulombsMul = UnitMegacoulombsMul;
pub type Kilocoulombs<T> = Quantity<T, UnitKilocoulombs>;
#[allow(non_upper_case_globals)]
pub static Kilocoulombs: UnitKilocoulombsMul = UnitKilocoulombsMul;
pub type Hectocoulombs<T> = Quantity<T, UnitHectocoulombs>;
#[allow(non_upper_case_globals)]
pub static Hectocoulombs: UnitHectocoulombsMul = UnitHectocoulombsMul;
pub type Decacoulombs<T> = Quantity<T, UnitDecacoulombs>;
#[allow(non_upper_case_globals)]
pub static Decacoulombs: UnitDecacoulombsMul = UnitDecacoulombsMul;
pub type Decicoulombs<T> = Quantity<T, UnitDecicoulombs>;
#[allow(non_upper_case_globals)]
pub static Decicoulombs: UnitDecicoulombsMul = UnitDecicoulombsMul;
pub type Centicoulombs<T> = Quantity<T, UnitCenticoulombs>;
#[allow(non_upper_case_globals)]
pub static Centicoulombs: UnitCenticoulombsMul = UnitCenticoulombsMul;
pub type Millicoulombs<T> = Quantity<T, UnitMillicoulombs>;
#[allow(non_upper_case_globals)]
pub static Millicoulombs: UnitMillicoulombsMul = UnitMillicoulombsMul;
pub type Microcoulombs<T> = Quantity<T, UnitMicrocoulombs>;
#[allow(non_upper_case_globals)]
pub static Microcoulombs: UnitMicrocoulombsMul = UnitMicrocoulombsMul;
pub type Nanocoulombs<T> = Quantity<T, UnitNanocoulombs>;
#[allow(non_upper_case_globals)]
pub static Nanocoulombs: UnitNanocoulombsMul = UnitNanocoulombsMul;
pub type Picocoulombs<T> = Quantity<T, UnitPicocoulombs>;
#[allow(non_upper_case_globals)]
pub static Picocoulombs: UnitPicocoulombsMul = UnitPicocoulombsMul;
pub type Femtocoulombs<T> = Quantity<T, UnitFemtocoulombs>;
#[allow(non_upper_case_globals)]
pub static Femtocoulombs: UnitFemtocoulombsMul = UnitFemtocoulombsMul;
pub type Attocoulombs<T> = Quantity<T, UnitAttocoulombs>;
#[allow(non_upper_case_globals)]
pub static Attocoulombs: UnitAttocoulombsMul = UnitAttocoulombsMul;
pub type Zeptocoulombs<T> = Quantity<T, UnitZeptocoulombs>;
#[allow(non_upper_case_globals)]
pub static Zeptocoulombs: UnitZeptocoulombsMul = UnitZeptocoulombsMul;
pub type Yoctocoulombs<T> = Quantity<T, UnitYoctocoulombs>;
#[allow(non_upper_case_globals)]
pub static Yoctocoulombs: UnitYoctocoulombsMul = UnitYoctocoulombsMul;
pub type Rontocoulombs<T> = Quantity<T, UnitRontocoulombs>;
#[allow(non_upper_case_globals)]
pub static Rontocoulombs: UnitRontocoulombsMul = UnitRontocoulombsMul;
pub type Quectocoulombs<T> = Quantity<T, UnitQuectocoulombs>;
#[allow(non_upper_case_globals)]
pub static Quectocoulombs: UnitQuectocoulombsMul = UnitQuectocoulombsMul;
pub struct UnitVolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitVolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitVolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitVolts {
    #[inline]
    fn clone(&self) -> UnitVolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitVolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitVolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitVolts {
    #[inline]
    fn eq(&self, other: &UnitVolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitVolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitVolts {
    fn default() -> Self {
        UnitVolts
    }
}
impl Add<UnitVolts> for UnitVolts {
    type Output = UnitVolts;
    #[inline]
    fn add(self, _: UnitVolts) -> Self::Output {
        UnitVolts
    }
}
impl AddAssign<UnitVolts> for UnitVolts {
    #[inline]
    fn add_assign(&mut self, _: UnitVolts) {}
}
impl Sub<UnitVolts> for UnitVolts {
    type Output = UnitVolts;
    #[inline]
    fn sub(self, _: UnitVolts) -> Self::Output {
        UnitVolts
    }
}
impl SubAssign<UnitVolts> for UnitVolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitVolts) {}
}
pub struct UnitVoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitVoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitVoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitVoltsMul {
    #[inline]
    fn clone(&self) -> UnitVoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitVoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitVoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitVoltsMul {
    #[inline]
    fn eq(&self, other: &UnitVoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitVoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitVoltsMul> for i8 {
    type Output = Quantity<i8, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for i16 {
    type Output = Quantity<i16, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for i32 {
    type Output = Quantity<i32, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for i64 {
    type Output = Quantity<i64, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for i128 {
    type Output = Quantity<i128, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for isize {
    type Output = Quantity<isize, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for u8 {
    type Output = Quantity<u8, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for u16 {
    type Output = Quantity<u16, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for u32 {
    type Output = Quantity<u32, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for u64 {
    type Output = Quantity<u64, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for u128 {
    type Output = Quantity<u128, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for usize {
    type Output = Quantity<usize, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for f32 {
    type Output = Quantity<f32, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
impl Mul<UnitVoltsMul> for f64 {
    type Output = Quantity<f64, UnitVolts>;
    fn mul(self, _: UnitVoltsMul) -> Self::Output {
        Quantity::new(self, UnitVolts)
    }
}
pub struct UnitQuettavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettavolts {
    #[inline]
    fn clone(&self) -> UnitQuettavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettavolts {
    #[inline]
    fn eq(&self, other: &UnitQuettavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettavolts {
    fn default() -> Self {
        UnitQuettavolts
    }
}
impl Add<UnitQuettavolts> for UnitQuettavolts {
    type Output = UnitQuettavolts;
    #[inline]
    fn add(self, _: UnitQuettavolts) -> Self::Output {
        UnitQuettavolts
    }
}
impl AddAssign<UnitQuettavolts> for UnitQuettavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettavolts) {}
}
impl Sub<UnitQuettavolts> for UnitQuettavolts {
    type Output = UnitQuettavolts;
    #[inline]
    fn sub(self, _: UnitQuettavolts) -> Self::Output {
        UnitQuettavolts
    }
}
impl SubAssign<UnitQuettavolts> for UnitQuettavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettavolts) {}
}
pub struct UnitQuettavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettavoltsMul {
    #[inline]
    fn clone(&self) -> UnitQuettavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettavoltsMul> for i8 {
    type Output = Quantity<i8, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for i16 {
    type Output = Quantity<i16, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for i32 {
    type Output = Quantity<i32, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for i64 {
    type Output = Quantity<i64, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for i128 {
    type Output = Quantity<i128, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for isize {
    type Output = Quantity<isize, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for u8 {
    type Output = Quantity<u8, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for u16 {
    type Output = Quantity<u16, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for u32 {
    type Output = Quantity<u32, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for u64 {
    type Output = Quantity<u64, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for u128 {
    type Output = Quantity<u128, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for usize {
    type Output = Quantity<usize, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for f32 {
    type Output = Quantity<f32, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
impl Mul<UnitQuettavoltsMul> for f64 {
    type Output = Quantity<f64, UnitQuettavolts>;
    fn mul(self, _: UnitQuettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuettavolts)
    }
}
pub struct UnitRonnavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnavolts {
    #[inline]
    fn clone(&self) -> UnitRonnavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnavolts {
    #[inline]
    fn eq(&self, other: &UnitRonnavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnavolts {
    fn default() -> Self {
        UnitRonnavolts
    }
}
impl Add<UnitRonnavolts> for UnitRonnavolts {
    type Output = UnitRonnavolts;
    #[inline]
    fn add(self, _: UnitRonnavolts) -> Self::Output {
        UnitRonnavolts
    }
}
impl AddAssign<UnitRonnavolts> for UnitRonnavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnavolts) {}
}
impl Sub<UnitRonnavolts> for UnitRonnavolts {
    type Output = UnitRonnavolts;
    #[inline]
    fn sub(self, _: UnitRonnavolts) -> Self::Output {
        UnitRonnavolts
    }
}
impl SubAssign<UnitRonnavolts> for UnitRonnavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnavolts) {}
}
pub struct UnitRonnavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnavoltsMul {
    #[inline]
    fn clone(&self) -> UnitRonnavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnavoltsMul> for i8 {
    type Output = Quantity<i8, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for i16 {
    type Output = Quantity<i16, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for i32 {
    type Output = Quantity<i32, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for i64 {
    type Output = Quantity<i64, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for i128 {
    type Output = Quantity<i128, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for isize {
    type Output = Quantity<isize, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for u8 {
    type Output = Quantity<u8, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for u16 {
    type Output = Quantity<u16, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for u32 {
    type Output = Quantity<u32, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for u64 {
    type Output = Quantity<u64, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for u128 {
    type Output = Quantity<u128, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for usize {
    type Output = Quantity<usize, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for f32 {
    type Output = Quantity<f32, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
impl Mul<UnitRonnavoltsMul> for f64 {
    type Output = Quantity<f64, UnitRonnavolts>;
    fn mul(self, _: UnitRonnavoltsMul) -> Self::Output {
        Quantity::new(self, UnitRonnavolts)
    }
}
pub struct UnitYottavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottavolts {
    #[inline]
    fn clone(&self) -> UnitYottavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottavolts {
    #[inline]
    fn eq(&self, other: &UnitYottavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottavolts {
    fn default() -> Self {
        UnitYottavolts
    }
}
impl Add<UnitYottavolts> for UnitYottavolts {
    type Output = UnitYottavolts;
    #[inline]
    fn add(self, _: UnitYottavolts) -> Self::Output {
        UnitYottavolts
    }
}
impl AddAssign<UnitYottavolts> for UnitYottavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitYottavolts) {}
}
impl Sub<UnitYottavolts> for UnitYottavolts {
    type Output = UnitYottavolts;
    #[inline]
    fn sub(self, _: UnitYottavolts) -> Self::Output {
        UnitYottavolts
    }
}
impl SubAssign<UnitYottavolts> for UnitYottavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottavolts) {}
}
pub struct UnitYottavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottavoltsMul {
    #[inline]
    fn clone(&self) -> UnitYottavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitYottavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottavoltsMul> for i8 {
    type Output = Quantity<i8, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for i16 {
    type Output = Quantity<i16, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for i32 {
    type Output = Quantity<i32, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for i64 {
    type Output = Quantity<i64, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for i128 {
    type Output = Quantity<i128, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for isize {
    type Output = Quantity<isize, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for u8 {
    type Output = Quantity<u8, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for u16 {
    type Output = Quantity<u16, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for u32 {
    type Output = Quantity<u32, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for u64 {
    type Output = Quantity<u64, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for u128 {
    type Output = Quantity<u128, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for usize {
    type Output = Quantity<usize, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for f32 {
    type Output = Quantity<f32, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
impl Mul<UnitYottavoltsMul> for f64 {
    type Output = Quantity<f64, UnitYottavolts>;
    fn mul(self, _: UnitYottavoltsMul) -> Self::Output {
        Quantity::new(self, UnitYottavolts)
    }
}
pub struct UnitZettavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettavolts {
    #[inline]
    fn clone(&self) -> UnitZettavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettavolts {
    #[inline]
    fn eq(&self, other: &UnitZettavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettavolts {
    fn default() -> Self {
        UnitZettavolts
    }
}
impl Add<UnitZettavolts> for UnitZettavolts {
    type Output = UnitZettavolts;
    #[inline]
    fn add(self, _: UnitZettavolts) -> Self::Output {
        UnitZettavolts
    }
}
impl AddAssign<UnitZettavolts> for UnitZettavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitZettavolts) {}
}
impl Sub<UnitZettavolts> for UnitZettavolts {
    type Output = UnitZettavolts;
    #[inline]
    fn sub(self, _: UnitZettavolts) -> Self::Output {
        UnitZettavolts
    }
}
impl SubAssign<UnitZettavolts> for UnitZettavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettavolts) {}
}
pub struct UnitZettavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettavoltsMul {
    #[inline]
    fn clone(&self) -> UnitZettavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitZettavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettavoltsMul> for i8 {
    type Output = Quantity<i8, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for i16 {
    type Output = Quantity<i16, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for i32 {
    type Output = Quantity<i32, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for i64 {
    type Output = Quantity<i64, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for i128 {
    type Output = Quantity<i128, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for isize {
    type Output = Quantity<isize, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for u8 {
    type Output = Quantity<u8, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for u16 {
    type Output = Quantity<u16, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for u32 {
    type Output = Quantity<u32, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for u64 {
    type Output = Quantity<u64, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for u128 {
    type Output = Quantity<u128, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for usize {
    type Output = Quantity<usize, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for f32 {
    type Output = Quantity<f32, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
impl Mul<UnitZettavoltsMul> for f64 {
    type Output = Quantity<f64, UnitZettavolts>;
    fn mul(self, _: UnitZettavoltsMul) -> Self::Output {
        Quantity::new(self, UnitZettavolts)
    }
}
pub struct UnitExavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExavolts {
    #[inline]
    fn clone(&self) -> UnitExavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExavolts {
    #[inline]
    fn eq(&self, other: &UnitExavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExavolts {
    fn default() -> Self {
        UnitExavolts
    }
}
impl Add<UnitExavolts> for UnitExavolts {
    type Output = UnitExavolts;
    #[inline]
    fn add(self, _: UnitExavolts) -> Self::Output {
        UnitExavolts
    }
}
impl AddAssign<UnitExavolts> for UnitExavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitExavolts) {}
}
impl Sub<UnitExavolts> for UnitExavolts {
    type Output = UnitExavolts;
    #[inline]
    fn sub(self, _: UnitExavolts) -> Self::Output {
        UnitExavolts
    }
}
impl SubAssign<UnitExavolts> for UnitExavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitExavolts) {}
}
pub struct UnitExavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExavoltsMul {
    #[inline]
    fn clone(&self) -> UnitExavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitExavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExavoltsMul> for i8 {
    type Output = Quantity<i8, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for i16 {
    type Output = Quantity<i16, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for i32 {
    type Output = Quantity<i32, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for i64 {
    type Output = Quantity<i64, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for i128 {
    type Output = Quantity<i128, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for isize {
    type Output = Quantity<isize, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for u8 {
    type Output = Quantity<u8, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for u16 {
    type Output = Quantity<u16, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for u32 {
    type Output = Quantity<u32, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for u64 {
    type Output = Quantity<u64, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for u128 {
    type Output = Quantity<u128, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for usize {
    type Output = Quantity<usize, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for f32 {
    type Output = Quantity<f32, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
impl Mul<UnitExavoltsMul> for f64 {
    type Output = Quantity<f64, UnitExavolts>;
    fn mul(self, _: UnitExavoltsMul) -> Self::Output {
        Quantity::new(self, UnitExavolts)
    }
}
pub struct UnitPetavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetavolts {
    #[inline]
    fn clone(&self) -> UnitPetavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetavolts {
    #[inline]
    fn eq(&self, other: &UnitPetavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetavolts {
    fn default() -> Self {
        UnitPetavolts
    }
}
impl Add<UnitPetavolts> for UnitPetavolts {
    type Output = UnitPetavolts;
    #[inline]
    fn add(self, _: UnitPetavolts) -> Self::Output {
        UnitPetavolts
    }
}
impl AddAssign<UnitPetavolts> for UnitPetavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitPetavolts) {}
}
impl Sub<UnitPetavolts> for UnitPetavolts {
    type Output = UnitPetavolts;
    #[inline]
    fn sub(self, _: UnitPetavolts) -> Self::Output {
        UnitPetavolts
    }
}
impl SubAssign<UnitPetavolts> for UnitPetavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetavolts) {}
}
pub struct UnitPetavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetavoltsMul {
    #[inline]
    fn clone(&self) -> UnitPetavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitPetavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetavoltsMul> for i8 {
    type Output = Quantity<i8, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for i16 {
    type Output = Quantity<i16, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for i32 {
    type Output = Quantity<i32, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for i64 {
    type Output = Quantity<i64, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for i128 {
    type Output = Quantity<i128, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for isize {
    type Output = Quantity<isize, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for u8 {
    type Output = Quantity<u8, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for u16 {
    type Output = Quantity<u16, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for u32 {
    type Output = Quantity<u32, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for u64 {
    type Output = Quantity<u64, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for u128 {
    type Output = Quantity<u128, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for usize {
    type Output = Quantity<usize, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for f32 {
    type Output = Quantity<f32, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
impl Mul<UnitPetavoltsMul> for f64 {
    type Output = Quantity<f64, UnitPetavolts>;
    fn mul(self, _: UnitPetavoltsMul) -> Self::Output {
        Quantity::new(self, UnitPetavolts)
    }
}
pub struct UnitTeravolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeravolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeravolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeravolts {
    #[inline]
    fn clone(&self) -> UnitTeravolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeravolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeravolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeravolts {
    #[inline]
    fn eq(&self, other: &UnitTeravolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeravolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeravolts {
    fn default() -> Self {
        UnitTeravolts
    }
}
impl Add<UnitTeravolts> for UnitTeravolts {
    type Output = UnitTeravolts;
    #[inline]
    fn add(self, _: UnitTeravolts) -> Self::Output {
        UnitTeravolts
    }
}
impl AddAssign<UnitTeravolts> for UnitTeravolts {
    #[inline]
    fn add_assign(&mut self, _: UnitTeravolts) {}
}
impl Sub<UnitTeravolts> for UnitTeravolts {
    type Output = UnitTeravolts;
    #[inline]
    fn sub(self, _: UnitTeravolts) -> Self::Output {
        UnitTeravolts
    }
}
impl SubAssign<UnitTeravolts> for UnitTeravolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeravolts) {}
}
pub struct UnitTeravoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeravoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeravoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeravoltsMul {
    #[inline]
    fn clone(&self) -> UnitTeravoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeravoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeravoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeravoltsMul {
    #[inline]
    fn eq(&self, other: &UnitTeravoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeravoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeravoltsMul> for i8 {
    type Output = Quantity<i8, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for i16 {
    type Output = Quantity<i16, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for i32 {
    type Output = Quantity<i32, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for i64 {
    type Output = Quantity<i64, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for i128 {
    type Output = Quantity<i128, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for isize {
    type Output = Quantity<isize, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for u8 {
    type Output = Quantity<u8, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for u16 {
    type Output = Quantity<u16, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for u32 {
    type Output = Quantity<u32, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for u64 {
    type Output = Quantity<u64, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for u128 {
    type Output = Quantity<u128, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for usize {
    type Output = Quantity<usize, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for f32 {
    type Output = Quantity<f32, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
impl Mul<UnitTeravoltsMul> for f64 {
    type Output = Quantity<f64, UnitTeravolts>;
    fn mul(self, _: UnitTeravoltsMul) -> Self::Output {
        Quantity::new(self, UnitTeravolts)
    }
}
pub struct UnitGigavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigavolts {
    #[inline]
    fn clone(&self) -> UnitGigavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigavolts {
    #[inline]
    fn eq(&self, other: &UnitGigavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigavolts {
    fn default() -> Self {
        UnitGigavolts
    }
}
impl Add<UnitGigavolts> for UnitGigavolts {
    type Output = UnitGigavolts;
    #[inline]
    fn add(self, _: UnitGigavolts) -> Self::Output {
        UnitGigavolts
    }
}
impl AddAssign<UnitGigavolts> for UnitGigavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitGigavolts) {}
}
impl Sub<UnitGigavolts> for UnitGigavolts {
    type Output = UnitGigavolts;
    #[inline]
    fn sub(self, _: UnitGigavolts) -> Self::Output {
        UnitGigavolts
    }
}
impl SubAssign<UnitGigavolts> for UnitGigavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigavolts) {}
}
pub struct UnitGigavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigavoltsMul {
    #[inline]
    fn clone(&self) -> UnitGigavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitGigavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigavoltsMul> for i8 {
    type Output = Quantity<i8, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for i16 {
    type Output = Quantity<i16, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for i32 {
    type Output = Quantity<i32, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for i64 {
    type Output = Quantity<i64, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for i128 {
    type Output = Quantity<i128, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for isize {
    type Output = Quantity<isize, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for u8 {
    type Output = Quantity<u8, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for u16 {
    type Output = Quantity<u16, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for u32 {
    type Output = Quantity<u32, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for u64 {
    type Output = Quantity<u64, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for u128 {
    type Output = Quantity<u128, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for usize {
    type Output = Quantity<usize, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for f32 {
    type Output = Quantity<f32, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
impl Mul<UnitGigavoltsMul> for f64 {
    type Output = Quantity<f64, UnitGigavolts>;
    fn mul(self, _: UnitGigavoltsMul) -> Self::Output {
        Quantity::new(self, UnitGigavolts)
    }
}
pub struct UnitMegavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegavolts {
    #[inline]
    fn clone(&self) -> UnitMegavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegavolts {
    #[inline]
    fn eq(&self, other: &UnitMegavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegavolts {
    fn default() -> Self {
        UnitMegavolts
    }
}
impl Add<UnitMegavolts> for UnitMegavolts {
    type Output = UnitMegavolts;
    #[inline]
    fn add(self, _: UnitMegavolts) -> Self::Output {
        UnitMegavolts
    }
}
impl AddAssign<UnitMegavolts> for UnitMegavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitMegavolts) {}
}
impl Sub<UnitMegavolts> for UnitMegavolts {
    type Output = UnitMegavolts;
    #[inline]
    fn sub(self, _: UnitMegavolts) -> Self::Output {
        UnitMegavolts
    }
}
impl SubAssign<UnitMegavolts> for UnitMegavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegavolts) {}
}
pub struct UnitMegavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegavoltsMul {
    #[inline]
    fn clone(&self) -> UnitMegavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitMegavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegavoltsMul> for i8 {
    type Output = Quantity<i8, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for i16 {
    type Output = Quantity<i16, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for i32 {
    type Output = Quantity<i32, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for i64 {
    type Output = Quantity<i64, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for i128 {
    type Output = Quantity<i128, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for isize {
    type Output = Quantity<isize, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for u8 {
    type Output = Quantity<u8, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for u16 {
    type Output = Quantity<u16, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for u32 {
    type Output = Quantity<u32, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for u64 {
    type Output = Quantity<u64, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for u128 {
    type Output = Quantity<u128, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for usize {
    type Output = Quantity<usize, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for f32 {
    type Output = Quantity<f32, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
impl Mul<UnitMegavoltsMul> for f64 {
    type Output = Quantity<f64, UnitMegavolts>;
    fn mul(self, _: UnitMegavoltsMul) -> Self::Output {
        Quantity::new(self, UnitMegavolts)
    }
}
pub struct UnitKilovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilovolts {
    #[inline]
    fn clone(&self) -> UnitKilovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilovolts {
    #[inline]
    fn eq(&self, other: &UnitKilovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilovolts {
    fn default() -> Self {
        UnitKilovolts
    }
}
impl Add<UnitKilovolts> for UnitKilovolts {
    type Output = UnitKilovolts;
    #[inline]
    fn add(self, _: UnitKilovolts) -> Self::Output {
        UnitKilovolts
    }
}
impl AddAssign<UnitKilovolts> for UnitKilovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitKilovolts) {}
}
impl Sub<UnitKilovolts> for UnitKilovolts {
    type Output = UnitKilovolts;
    #[inline]
    fn sub(self, _: UnitKilovolts) -> Self::Output {
        UnitKilovolts
    }
}
impl SubAssign<UnitKilovolts> for UnitKilovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilovolts) {}
}
pub struct UnitKilovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilovoltsMul {
    #[inline]
    fn clone(&self) -> UnitKilovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitKilovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilovoltsMul> for i8 {
    type Output = Quantity<i8, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for i16 {
    type Output = Quantity<i16, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for i32 {
    type Output = Quantity<i32, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for i64 {
    type Output = Quantity<i64, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for i128 {
    type Output = Quantity<i128, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for isize {
    type Output = Quantity<isize, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for u8 {
    type Output = Quantity<u8, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for u16 {
    type Output = Quantity<u16, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for u32 {
    type Output = Quantity<u32, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for u64 {
    type Output = Quantity<u64, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for u128 {
    type Output = Quantity<u128, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for usize {
    type Output = Quantity<usize, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for f32 {
    type Output = Quantity<f32, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
impl Mul<UnitKilovoltsMul> for f64 {
    type Output = Quantity<f64, UnitKilovolts>;
    fn mul(self, _: UnitKilovoltsMul) -> Self::Output {
        Quantity::new(self, UnitKilovolts)
    }
}
pub struct UnitHectovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectovolts {
    #[inline]
    fn clone(&self) -> UnitHectovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectovolts {
    #[inline]
    fn eq(&self, other: &UnitHectovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectovolts {
    fn default() -> Self {
        UnitHectovolts
    }
}
impl Add<UnitHectovolts> for UnitHectovolts {
    type Output = UnitHectovolts;
    #[inline]
    fn add(self, _: UnitHectovolts) -> Self::Output {
        UnitHectovolts
    }
}
impl AddAssign<UnitHectovolts> for UnitHectovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitHectovolts) {}
}
impl Sub<UnitHectovolts> for UnitHectovolts {
    type Output = UnitHectovolts;
    #[inline]
    fn sub(self, _: UnitHectovolts) -> Self::Output {
        UnitHectovolts
    }
}
impl SubAssign<UnitHectovolts> for UnitHectovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectovolts) {}
}
pub struct UnitHectovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectovoltsMul {
    #[inline]
    fn clone(&self) -> UnitHectovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitHectovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectovoltsMul> for i8 {
    type Output = Quantity<i8, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for i16 {
    type Output = Quantity<i16, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for i32 {
    type Output = Quantity<i32, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for i64 {
    type Output = Quantity<i64, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for i128 {
    type Output = Quantity<i128, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for isize {
    type Output = Quantity<isize, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for u8 {
    type Output = Quantity<u8, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for u16 {
    type Output = Quantity<u16, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for u32 {
    type Output = Quantity<u32, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for u64 {
    type Output = Quantity<u64, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for u128 {
    type Output = Quantity<u128, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for usize {
    type Output = Quantity<usize, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for f32 {
    type Output = Quantity<f32, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
impl Mul<UnitHectovoltsMul> for f64 {
    type Output = Quantity<f64, UnitHectovolts>;
    fn mul(self, _: UnitHectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitHectovolts)
    }
}
pub struct UnitDecavolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecavolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecavolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecavolts {
    #[inline]
    fn clone(&self) -> UnitDecavolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecavolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecavolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecavolts {
    #[inline]
    fn eq(&self, other: &UnitDecavolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecavolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecavolts {
    fn default() -> Self {
        UnitDecavolts
    }
}
impl Add<UnitDecavolts> for UnitDecavolts {
    type Output = UnitDecavolts;
    #[inline]
    fn add(self, _: UnitDecavolts) -> Self::Output {
        UnitDecavolts
    }
}
impl AddAssign<UnitDecavolts> for UnitDecavolts {
    #[inline]
    fn add_assign(&mut self, _: UnitDecavolts) {}
}
impl Sub<UnitDecavolts> for UnitDecavolts {
    type Output = UnitDecavolts;
    #[inline]
    fn sub(self, _: UnitDecavolts) -> Self::Output {
        UnitDecavolts
    }
}
impl SubAssign<UnitDecavolts> for UnitDecavolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecavolts) {}
}
pub struct UnitDecavoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecavoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecavoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecavoltsMul {
    #[inline]
    fn clone(&self) -> UnitDecavoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecavoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecavoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecavoltsMul {
    #[inline]
    fn eq(&self, other: &UnitDecavoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecavoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecavoltsMul> for i8 {
    type Output = Quantity<i8, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for i16 {
    type Output = Quantity<i16, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for i32 {
    type Output = Quantity<i32, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for i64 {
    type Output = Quantity<i64, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for i128 {
    type Output = Quantity<i128, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for isize {
    type Output = Quantity<isize, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for u8 {
    type Output = Quantity<u8, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for u16 {
    type Output = Quantity<u16, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for u32 {
    type Output = Quantity<u32, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for u64 {
    type Output = Quantity<u64, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for u128 {
    type Output = Quantity<u128, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for usize {
    type Output = Quantity<usize, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for f32 {
    type Output = Quantity<f32, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
impl Mul<UnitDecavoltsMul> for f64 {
    type Output = Quantity<f64, UnitDecavolts>;
    fn mul(self, _: UnitDecavoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecavolts)
    }
}
pub struct UnitDecivolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecivolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecivolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecivolts {
    #[inline]
    fn clone(&self) -> UnitDecivolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecivolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecivolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecivolts {
    #[inline]
    fn eq(&self, other: &UnitDecivolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecivolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecivolts {
    fn default() -> Self {
        UnitDecivolts
    }
}
impl Add<UnitDecivolts> for UnitDecivolts {
    type Output = UnitDecivolts;
    #[inline]
    fn add(self, _: UnitDecivolts) -> Self::Output {
        UnitDecivolts
    }
}
impl AddAssign<UnitDecivolts> for UnitDecivolts {
    #[inline]
    fn add_assign(&mut self, _: UnitDecivolts) {}
}
impl Sub<UnitDecivolts> for UnitDecivolts {
    type Output = UnitDecivolts;
    #[inline]
    fn sub(self, _: UnitDecivolts) -> Self::Output {
        UnitDecivolts
    }
}
impl SubAssign<UnitDecivolts> for UnitDecivolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecivolts) {}
}
pub struct UnitDecivoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecivoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecivoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecivoltsMul {
    #[inline]
    fn clone(&self) -> UnitDecivoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecivoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecivoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecivoltsMul {
    #[inline]
    fn eq(&self, other: &UnitDecivoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecivoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecivoltsMul> for i8 {
    type Output = Quantity<i8, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for i16 {
    type Output = Quantity<i16, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for i32 {
    type Output = Quantity<i32, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for i64 {
    type Output = Quantity<i64, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for i128 {
    type Output = Quantity<i128, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for isize {
    type Output = Quantity<isize, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for u8 {
    type Output = Quantity<u8, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for u16 {
    type Output = Quantity<u16, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for u32 {
    type Output = Quantity<u32, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for u64 {
    type Output = Quantity<u64, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for u128 {
    type Output = Quantity<u128, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for usize {
    type Output = Quantity<usize, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for f32 {
    type Output = Quantity<f32, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
impl Mul<UnitDecivoltsMul> for f64 {
    type Output = Quantity<f64, UnitDecivolts>;
    fn mul(self, _: UnitDecivoltsMul) -> Self::Output {
        Quantity::new(self, UnitDecivolts)
    }
}
pub struct UnitCentivolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentivolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentivolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentivolts {
    #[inline]
    fn clone(&self) -> UnitCentivolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentivolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentivolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentivolts {
    #[inline]
    fn eq(&self, other: &UnitCentivolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentivolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentivolts {
    fn default() -> Self {
        UnitCentivolts
    }
}
impl Add<UnitCentivolts> for UnitCentivolts {
    type Output = UnitCentivolts;
    #[inline]
    fn add(self, _: UnitCentivolts) -> Self::Output {
        UnitCentivolts
    }
}
impl AddAssign<UnitCentivolts> for UnitCentivolts {
    #[inline]
    fn add_assign(&mut self, _: UnitCentivolts) {}
}
impl Sub<UnitCentivolts> for UnitCentivolts {
    type Output = UnitCentivolts;
    #[inline]
    fn sub(self, _: UnitCentivolts) -> Self::Output {
        UnitCentivolts
    }
}
impl SubAssign<UnitCentivolts> for UnitCentivolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentivolts) {}
}
pub struct UnitCentivoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentivoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentivoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentivoltsMul {
    #[inline]
    fn clone(&self) -> UnitCentivoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentivoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentivoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentivoltsMul {
    #[inline]
    fn eq(&self, other: &UnitCentivoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentivoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentivoltsMul> for i8 {
    type Output = Quantity<i8, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for i16 {
    type Output = Quantity<i16, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for i32 {
    type Output = Quantity<i32, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for i64 {
    type Output = Quantity<i64, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for i128 {
    type Output = Quantity<i128, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for isize {
    type Output = Quantity<isize, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for u8 {
    type Output = Quantity<u8, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for u16 {
    type Output = Quantity<u16, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for u32 {
    type Output = Quantity<u32, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for u64 {
    type Output = Quantity<u64, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for u128 {
    type Output = Quantity<u128, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for usize {
    type Output = Quantity<usize, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for f32 {
    type Output = Quantity<f32, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
impl Mul<UnitCentivoltsMul> for f64 {
    type Output = Quantity<f64, UnitCentivolts>;
    fn mul(self, _: UnitCentivoltsMul) -> Self::Output {
        Quantity::new(self, UnitCentivolts)
    }
}
pub struct UnitMillivolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillivolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillivolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillivolts {
    #[inline]
    fn clone(&self) -> UnitMillivolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillivolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillivolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillivolts {
    #[inline]
    fn eq(&self, other: &UnitMillivolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillivolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillivolts {
    fn default() -> Self {
        UnitMillivolts
    }
}
impl Add<UnitMillivolts> for UnitMillivolts {
    type Output = UnitMillivolts;
    #[inline]
    fn add(self, _: UnitMillivolts) -> Self::Output {
        UnitMillivolts
    }
}
impl AddAssign<UnitMillivolts> for UnitMillivolts {
    #[inline]
    fn add_assign(&mut self, _: UnitMillivolts) {}
}
impl Sub<UnitMillivolts> for UnitMillivolts {
    type Output = UnitMillivolts;
    #[inline]
    fn sub(self, _: UnitMillivolts) -> Self::Output {
        UnitMillivolts
    }
}
impl SubAssign<UnitMillivolts> for UnitMillivolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillivolts) {}
}
pub struct UnitMillivoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillivoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillivoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillivoltsMul {
    #[inline]
    fn clone(&self) -> UnitMillivoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillivoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillivoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillivoltsMul {
    #[inline]
    fn eq(&self, other: &UnitMillivoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillivoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillivoltsMul> for i8 {
    type Output = Quantity<i8, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for i16 {
    type Output = Quantity<i16, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for i32 {
    type Output = Quantity<i32, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for i64 {
    type Output = Quantity<i64, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for i128 {
    type Output = Quantity<i128, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for isize {
    type Output = Quantity<isize, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for u8 {
    type Output = Quantity<u8, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for u16 {
    type Output = Quantity<u16, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for u32 {
    type Output = Quantity<u32, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for u64 {
    type Output = Quantity<u64, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for u128 {
    type Output = Quantity<u128, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for usize {
    type Output = Quantity<usize, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for f32 {
    type Output = Quantity<f32, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
impl Mul<UnitMillivoltsMul> for f64 {
    type Output = Quantity<f64, UnitMillivolts>;
    fn mul(self, _: UnitMillivoltsMul) -> Self::Output {
        Quantity::new(self, UnitMillivolts)
    }
}
pub struct UnitMicrovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrovolts {
    #[inline]
    fn clone(&self) -> UnitMicrovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrovolts {
    #[inline]
    fn eq(&self, other: &UnitMicrovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrovolts {
    fn default() -> Self {
        UnitMicrovolts
    }
}
impl Add<UnitMicrovolts> for UnitMicrovolts {
    type Output = UnitMicrovolts;
    #[inline]
    fn add(self, _: UnitMicrovolts) -> Self::Output {
        UnitMicrovolts
    }
}
impl AddAssign<UnitMicrovolts> for UnitMicrovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrovolts) {}
}
impl Sub<UnitMicrovolts> for UnitMicrovolts {
    type Output = UnitMicrovolts;
    #[inline]
    fn sub(self, _: UnitMicrovolts) -> Self::Output {
        UnitMicrovolts
    }
}
impl SubAssign<UnitMicrovolts> for UnitMicrovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrovolts) {}
}
pub struct UnitMicrovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrovoltsMul {
    #[inline]
    fn clone(&self) -> UnitMicrovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrovoltsMul> for i8 {
    type Output = Quantity<i8, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for i16 {
    type Output = Quantity<i16, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for i32 {
    type Output = Quantity<i32, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for i64 {
    type Output = Quantity<i64, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for i128 {
    type Output = Quantity<i128, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for isize {
    type Output = Quantity<isize, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for u8 {
    type Output = Quantity<u8, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for u16 {
    type Output = Quantity<u16, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for u32 {
    type Output = Quantity<u32, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for u64 {
    type Output = Quantity<u64, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for u128 {
    type Output = Quantity<u128, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for usize {
    type Output = Quantity<usize, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for f32 {
    type Output = Quantity<f32, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
impl Mul<UnitMicrovoltsMul> for f64 {
    type Output = Quantity<f64, UnitMicrovolts>;
    fn mul(self, _: UnitMicrovoltsMul) -> Self::Output {
        Quantity::new(self, UnitMicrovolts)
    }
}
pub struct UnitNanovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanovolts {
    #[inline]
    fn clone(&self) -> UnitNanovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanovolts {
    #[inline]
    fn eq(&self, other: &UnitNanovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanovolts {
    fn default() -> Self {
        UnitNanovolts
    }
}
impl Add<UnitNanovolts> for UnitNanovolts {
    type Output = UnitNanovolts;
    #[inline]
    fn add(self, _: UnitNanovolts) -> Self::Output {
        UnitNanovolts
    }
}
impl AddAssign<UnitNanovolts> for UnitNanovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitNanovolts) {}
}
impl Sub<UnitNanovolts> for UnitNanovolts {
    type Output = UnitNanovolts;
    #[inline]
    fn sub(self, _: UnitNanovolts) -> Self::Output {
        UnitNanovolts
    }
}
impl SubAssign<UnitNanovolts> for UnitNanovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanovolts) {}
}
pub struct UnitNanovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanovoltsMul {
    #[inline]
    fn clone(&self) -> UnitNanovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitNanovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanovoltsMul> for i8 {
    type Output = Quantity<i8, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for i16 {
    type Output = Quantity<i16, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for i32 {
    type Output = Quantity<i32, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for i64 {
    type Output = Quantity<i64, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for i128 {
    type Output = Quantity<i128, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for isize {
    type Output = Quantity<isize, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for u8 {
    type Output = Quantity<u8, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for u16 {
    type Output = Quantity<u16, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for u32 {
    type Output = Quantity<u32, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for u64 {
    type Output = Quantity<u64, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for u128 {
    type Output = Quantity<u128, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for usize {
    type Output = Quantity<usize, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for f32 {
    type Output = Quantity<f32, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
impl Mul<UnitNanovoltsMul> for f64 {
    type Output = Quantity<f64, UnitNanovolts>;
    fn mul(self, _: UnitNanovoltsMul) -> Self::Output {
        Quantity::new(self, UnitNanovolts)
    }
}
pub struct UnitPicovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicovolts {
    #[inline]
    fn clone(&self) -> UnitPicovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicovolts {
    #[inline]
    fn eq(&self, other: &UnitPicovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicovolts {
    fn default() -> Self {
        UnitPicovolts
    }
}
impl Add<UnitPicovolts> for UnitPicovolts {
    type Output = UnitPicovolts;
    #[inline]
    fn add(self, _: UnitPicovolts) -> Self::Output {
        UnitPicovolts
    }
}
impl AddAssign<UnitPicovolts> for UnitPicovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitPicovolts) {}
}
impl Sub<UnitPicovolts> for UnitPicovolts {
    type Output = UnitPicovolts;
    #[inline]
    fn sub(self, _: UnitPicovolts) -> Self::Output {
        UnitPicovolts
    }
}
impl SubAssign<UnitPicovolts> for UnitPicovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicovolts) {}
}
pub struct UnitPicovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicovoltsMul {
    #[inline]
    fn clone(&self) -> UnitPicovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitPicovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicovoltsMul> for i8 {
    type Output = Quantity<i8, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for i16 {
    type Output = Quantity<i16, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for i32 {
    type Output = Quantity<i32, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for i64 {
    type Output = Quantity<i64, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for i128 {
    type Output = Quantity<i128, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for isize {
    type Output = Quantity<isize, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for u8 {
    type Output = Quantity<u8, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for u16 {
    type Output = Quantity<u16, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for u32 {
    type Output = Quantity<u32, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for u64 {
    type Output = Quantity<u64, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for u128 {
    type Output = Quantity<u128, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for usize {
    type Output = Quantity<usize, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for f32 {
    type Output = Quantity<f32, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
impl Mul<UnitPicovoltsMul> for f64 {
    type Output = Quantity<f64, UnitPicovolts>;
    fn mul(self, _: UnitPicovoltsMul) -> Self::Output {
        Quantity::new(self, UnitPicovolts)
    }
}
pub struct UnitFemtovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtovolts {
    #[inline]
    fn clone(&self) -> UnitFemtovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtovolts {
    #[inline]
    fn eq(&self, other: &UnitFemtovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtovolts {
    fn default() -> Self {
        UnitFemtovolts
    }
}
impl Add<UnitFemtovolts> for UnitFemtovolts {
    type Output = UnitFemtovolts;
    #[inline]
    fn add(self, _: UnitFemtovolts) -> Self::Output {
        UnitFemtovolts
    }
}
impl AddAssign<UnitFemtovolts> for UnitFemtovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtovolts) {}
}
impl Sub<UnitFemtovolts> for UnitFemtovolts {
    type Output = UnitFemtovolts;
    #[inline]
    fn sub(self, _: UnitFemtovolts) -> Self::Output {
        UnitFemtovolts
    }
}
impl SubAssign<UnitFemtovolts> for UnitFemtovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtovolts) {}
}
pub struct UnitFemtovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtovoltsMul {
    #[inline]
    fn clone(&self) -> UnitFemtovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtovoltsMul> for i8 {
    type Output = Quantity<i8, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for i16 {
    type Output = Quantity<i16, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for i32 {
    type Output = Quantity<i32, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for i64 {
    type Output = Quantity<i64, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for i128 {
    type Output = Quantity<i128, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for isize {
    type Output = Quantity<isize, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for u8 {
    type Output = Quantity<u8, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for u16 {
    type Output = Quantity<u16, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for u32 {
    type Output = Quantity<u32, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for u64 {
    type Output = Quantity<u64, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for u128 {
    type Output = Quantity<u128, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for usize {
    type Output = Quantity<usize, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for f32 {
    type Output = Quantity<f32, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
impl Mul<UnitFemtovoltsMul> for f64 {
    type Output = Quantity<f64, UnitFemtovolts>;
    fn mul(self, _: UnitFemtovoltsMul) -> Self::Output {
        Quantity::new(self, UnitFemtovolts)
    }
}
pub struct UnitAttovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttovolts {
    #[inline]
    fn clone(&self) -> UnitAttovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttovolts {
    #[inline]
    fn eq(&self, other: &UnitAttovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttovolts {
    fn default() -> Self {
        UnitAttovolts
    }
}
impl Add<UnitAttovolts> for UnitAttovolts {
    type Output = UnitAttovolts;
    #[inline]
    fn add(self, _: UnitAttovolts) -> Self::Output {
        UnitAttovolts
    }
}
impl AddAssign<UnitAttovolts> for UnitAttovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitAttovolts) {}
}
impl Sub<UnitAttovolts> for UnitAttovolts {
    type Output = UnitAttovolts;
    #[inline]
    fn sub(self, _: UnitAttovolts) -> Self::Output {
        UnitAttovolts
    }
}
impl SubAssign<UnitAttovolts> for UnitAttovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttovolts) {}
}
pub struct UnitAttovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttovoltsMul {
    #[inline]
    fn clone(&self) -> UnitAttovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitAttovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttovoltsMul> for i8 {
    type Output = Quantity<i8, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for i16 {
    type Output = Quantity<i16, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for i32 {
    type Output = Quantity<i32, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for i64 {
    type Output = Quantity<i64, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for i128 {
    type Output = Quantity<i128, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for isize {
    type Output = Quantity<isize, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for u8 {
    type Output = Quantity<u8, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for u16 {
    type Output = Quantity<u16, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for u32 {
    type Output = Quantity<u32, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for u64 {
    type Output = Quantity<u64, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for u128 {
    type Output = Quantity<u128, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for usize {
    type Output = Quantity<usize, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for f32 {
    type Output = Quantity<f32, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
impl Mul<UnitAttovoltsMul> for f64 {
    type Output = Quantity<f64, UnitAttovolts>;
    fn mul(self, _: UnitAttovoltsMul) -> Self::Output {
        Quantity::new(self, UnitAttovolts)
    }
}
pub struct UnitZeptovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptovolts {
    #[inline]
    fn clone(&self) -> UnitZeptovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptovolts {
    #[inline]
    fn eq(&self, other: &UnitZeptovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptovolts {
    fn default() -> Self {
        UnitZeptovolts
    }
}
impl Add<UnitZeptovolts> for UnitZeptovolts {
    type Output = UnitZeptovolts;
    #[inline]
    fn add(self, _: UnitZeptovolts) -> Self::Output {
        UnitZeptovolts
    }
}
impl AddAssign<UnitZeptovolts> for UnitZeptovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptovolts) {}
}
impl Sub<UnitZeptovolts> for UnitZeptovolts {
    type Output = UnitZeptovolts;
    #[inline]
    fn sub(self, _: UnitZeptovolts) -> Self::Output {
        UnitZeptovolts
    }
}
impl SubAssign<UnitZeptovolts> for UnitZeptovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptovolts) {}
}
pub struct UnitZeptovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptovoltsMul {
    #[inline]
    fn clone(&self) -> UnitZeptovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptovoltsMul> for i8 {
    type Output = Quantity<i8, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for i16 {
    type Output = Quantity<i16, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for i32 {
    type Output = Quantity<i32, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for i64 {
    type Output = Quantity<i64, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for i128 {
    type Output = Quantity<i128, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for isize {
    type Output = Quantity<isize, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for u8 {
    type Output = Quantity<u8, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for u16 {
    type Output = Quantity<u16, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for u32 {
    type Output = Quantity<u32, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for u64 {
    type Output = Quantity<u64, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for u128 {
    type Output = Quantity<u128, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for usize {
    type Output = Quantity<usize, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for f32 {
    type Output = Quantity<f32, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
impl Mul<UnitZeptovoltsMul> for f64 {
    type Output = Quantity<f64, UnitZeptovolts>;
    fn mul(self, _: UnitZeptovoltsMul) -> Self::Output {
        Quantity::new(self, UnitZeptovolts)
    }
}
pub struct UnitYoctovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctovolts {
    #[inline]
    fn clone(&self) -> UnitYoctovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctovolts {
    #[inline]
    fn eq(&self, other: &UnitYoctovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctovolts {
    fn default() -> Self {
        UnitYoctovolts
    }
}
impl Add<UnitYoctovolts> for UnitYoctovolts {
    type Output = UnitYoctovolts;
    #[inline]
    fn add(self, _: UnitYoctovolts) -> Self::Output {
        UnitYoctovolts
    }
}
impl AddAssign<UnitYoctovolts> for UnitYoctovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctovolts) {}
}
impl Sub<UnitYoctovolts> for UnitYoctovolts {
    type Output = UnitYoctovolts;
    #[inline]
    fn sub(self, _: UnitYoctovolts) -> Self::Output {
        UnitYoctovolts
    }
}
impl SubAssign<UnitYoctovolts> for UnitYoctovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctovolts) {}
}
pub struct UnitYoctovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctovoltsMul {
    #[inline]
    fn clone(&self) -> UnitYoctovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctovoltsMul> for i8 {
    type Output = Quantity<i8, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for i16 {
    type Output = Quantity<i16, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for i32 {
    type Output = Quantity<i32, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for i64 {
    type Output = Quantity<i64, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for i128 {
    type Output = Quantity<i128, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for isize {
    type Output = Quantity<isize, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for u8 {
    type Output = Quantity<u8, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for u16 {
    type Output = Quantity<u16, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for u32 {
    type Output = Quantity<u32, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for u64 {
    type Output = Quantity<u64, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for u128 {
    type Output = Quantity<u128, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for usize {
    type Output = Quantity<usize, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for f32 {
    type Output = Quantity<f32, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
impl Mul<UnitYoctovoltsMul> for f64 {
    type Output = Quantity<f64, UnitYoctovolts>;
    fn mul(self, _: UnitYoctovoltsMul) -> Self::Output {
        Quantity::new(self, UnitYoctovolts)
    }
}
pub struct UnitRontovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontovolts {
    #[inline]
    fn clone(&self) -> UnitRontovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontovolts {
    #[inline]
    fn eq(&self, other: &UnitRontovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontovolts {
    fn default() -> Self {
        UnitRontovolts
    }
}
impl Add<UnitRontovolts> for UnitRontovolts {
    type Output = UnitRontovolts;
    #[inline]
    fn add(self, _: UnitRontovolts) -> Self::Output {
        UnitRontovolts
    }
}
impl AddAssign<UnitRontovolts> for UnitRontovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitRontovolts) {}
}
impl Sub<UnitRontovolts> for UnitRontovolts {
    type Output = UnitRontovolts;
    #[inline]
    fn sub(self, _: UnitRontovolts) -> Self::Output {
        UnitRontovolts
    }
}
impl SubAssign<UnitRontovolts> for UnitRontovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontovolts) {}
}
pub struct UnitRontovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontovoltsMul {
    #[inline]
    fn clone(&self) -> UnitRontovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitRontovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontovoltsMul> for i8 {
    type Output = Quantity<i8, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for i16 {
    type Output = Quantity<i16, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for i32 {
    type Output = Quantity<i32, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for i64 {
    type Output = Quantity<i64, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for i128 {
    type Output = Quantity<i128, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for isize {
    type Output = Quantity<isize, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for u8 {
    type Output = Quantity<u8, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for u16 {
    type Output = Quantity<u16, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for u32 {
    type Output = Quantity<u32, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for u64 {
    type Output = Quantity<u64, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for u128 {
    type Output = Quantity<u128, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for usize {
    type Output = Quantity<usize, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for f32 {
    type Output = Quantity<f32, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
impl Mul<UnitRontovoltsMul> for f64 {
    type Output = Quantity<f64, UnitRontovolts>;
    fn mul(self, _: UnitRontovoltsMul) -> Self::Output {
        Quantity::new(self, UnitRontovolts)
    }
}
pub struct UnitQuectovolts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectovolts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectovolts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectovolts {
    #[inline]
    fn clone(&self) -> UnitQuectovolts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectovolts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectovolts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectovolts {
    #[inline]
    fn eq(&self, other: &UnitQuectovolts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectovolts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectovolts {
    fn default() -> Self {
        UnitQuectovolts
    }
}
impl Add<UnitQuectovolts> for UnitQuectovolts {
    type Output = UnitQuectovolts;
    #[inline]
    fn add(self, _: UnitQuectovolts) -> Self::Output {
        UnitQuectovolts
    }
}
impl AddAssign<UnitQuectovolts> for UnitQuectovolts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectovolts) {}
}
impl Sub<UnitQuectovolts> for UnitQuectovolts {
    type Output = UnitQuectovolts;
    #[inline]
    fn sub(self, _: UnitQuectovolts) -> Self::Output {
        UnitQuectovolts
    }
}
impl SubAssign<UnitQuectovolts> for UnitQuectovolts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectovolts) {}
}
pub struct UnitQuectovoltsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectovoltsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectovoltsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectovoltsMul {
    #[inline]
    fn clone(&self) -> UnitQuectovoltsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectovoltsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectovoltsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectovoltsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectovoltsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectovoltsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectovoltsMul> for i8 {
    type Output = Quantity<i8, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for i16 {
    type Output = Quantity<i16, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for i32 {
    type Output = Quantity<i32, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for i64 {
    type Output = Quantity<i64, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for i128 {
    type Output = Quantity<i128, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for isize {
    type Output = Quantity<isize, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for u8 {
    type Output = Quantity<u8, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for u16 {
    type Output = Quantity<u16, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for u32 {
    type Output = Quantity<u32, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for u64 {
    type Output = Quantity<u64, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for u128 {
    type Output = Quantity<u128, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for usize {
    type Output = Quantity<usize, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for f32 {
    type Output = Quantity<f32, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
impl Mul<UnitQuectovoltsMul> for f64 {
    type Output = Quantity<f64, UnitQuectovolts>;
    fn mul(self, _: UnitQuectovoltsMul) -> Self::Output {
        Quantity::new(self, UnitQuectovolts)
    }
}
pub type Volts<T> = Quantity<T, UnitVolts>;
#[allow(non_upper_case_globals)]
pub static Volts: UnitVoltsMul = UnitVoltsMul;
pub type Quettavolts<T> = Quantity<T, UnitQuettavolts>;
#[allow(non_upper_case_globals)]
pub static Quettavolts: UnitQuettavoltsMul = UnitQuettavoltsMul;
pub type Ronnavolts<T> = Quantity<T, UnitRonnavolts>;
#[allow(non_upper_case_globals)]
pub static Ronnavolts: UnitRonnavoltsMul = UnitRonnavoltsMul;
pub type Yottavolts<T> = Quantity<T, UnitYottavolts>;
#[allow(non_upper_case_globals)]
pub static Yottavolts: UnitYottavoltsMul = UnitYottavoltsMul;
pub type Zettavolts<T> = Quantity<T, UnitZettavolts>;
#[allow(non_upper_case_globals)]
pub static Zettavolts: UnitZettavoltsMul = UnitZettavoltsMul;
pub type Exavolts<T> = Quantity<T, UnitExavolts>;
#[allow(non_upper_case_globals)]
pub static Exavolts: UnitExavoltsMul = UnitExavoltsMul;
pub type Petavolts<T> = Quantity<T, UnitPetavolts>;
#[allow(non_upper_case_globals)]
pub static Petavolts: UnitPetavoltsMul = UnitPetavoltsMul;
pub type Teravolts<T> = Quantity<T, UnitTeravolts>;
#[allow(non_upper_case_globals)]
pub static Teravolts: UnitTeravoltsMul = UnitTeravoltsMul;
pub type Gigavolts<T> = Quantity<T, UnitGigavolts>;
#[allow(non_upper_case_globals)]
pub static Gigavolts: UnitGigavoltsMul = UnitGigavoltsMul;
pub type Megavolts<T> = Quantity<T, UnitMegavolts>;
#[allow(non_upper_case_globals)]
pub static Megavolts: UnitMegavoltsMul = UnitMegavoltsMul;
pub type Kilovolts<T> = Quantity<T, UnitKilovolts>;
#[allow(non_upper_case_globals)]
pub static Kilovolts: UnitKilovoltsMul = UnitKilovoltsMul;
pub type Hectovolts<T> = Quantity<T, UnitHectovolts>;
#[allow(non_upper_case_globals)]
pub static Hectovolts: UnitHectovoltsMul = UnitHectovoltsMul;
pub type Decavolts<T> = Quantity<T, UnitDecavolts>;
#[allow(non_upper_case_globals)]
pub static Decavolts: UnitDecavoltsMul = UnitDecavoltsMul;
pub type Decivolts<T> = Quantity<T, UnitDecivolts>;
#[allow(non_upper_case_globals)]
pub static Decivolts: UnitDecivoltsMul = UnitDecivoltsMul;
pub type Centivolts<T> = Quantity<T, UnitCentivolts>;
#[allow(non_upper_case_globals)]
pub static Centivolts: UnitCentivoltsMul = UnitCentivoltsMul;
pub type Millivolts<T> = Quantity<T, UnitMillivolts>;
#[allow(non_upper_case_globals)]
pub static Millivolts: UnitMillivoltsMul = UnitMillivoltsMul;
pub type Microvolts<T> = Quantity<T, UnitMicrovolts>;
#[allow(non_upper_case_globals)]
pub static Microvolts: UnitMicrovoltsMul = UnitMicrovoltsMul;
pub type Nanovolts<T> = Quantity<T, UnitNanovolts>;
#[allow(non_upper_case_globals)]
pub static Nanovolts: UnitNanovoltsMul = UnitNanovoltsMul;
pub type Picovolts<T> = Quantity<T, UnitPicovolts>;
#[allow(non_upper_case_globals)]
pub static Picovolts: UnitPicovoltsMul = UnitPicovoltsMul;
pub type Femtovolts<T> = Quantity<T, UnitFemtovolts>;
#[allow(non_upper_case_globals)]
pub static Femtovolts: UnitFemtovoltsMul = UnitFemtovoltsMul;
pub type Attovolts<T> = Quantity<T, UnitAttovolts>;
#[allow(non_upper_case_globals)]
pub static Attovolts: UnitAttovoltsMul = UnitAttovoltsMul;
pub type Zeptovolts<T> = Quantity<T, UnitZeptovolts>;
#[allow(non_upper_case_globals)]
pub static Zeptovolts: UnitZeptovoltsMul = UnitZeptovoltsMul;
pub type Yoctovolts<T> = Quantity<T, UnitYoctovolts>;
#[allow(non_upper_case_globals)]
pub static Yoctovolts: UnitYoctovoltsMul = UnitYoctovoltsMul;
pub type Rontovolts<T> = Quantity<T, UnitRontovolts>;
#[allow(non_upper_case_globals)]
pub static Rontovolts: UnitRontovoltsMul = UnitRontovoltsMul;
pub type Quectovolts<T> = Quantity<T, UnitQuectovolts>;
#[allow(non_upper_case_globals)]
pub static Quectovolts: UnitQuectovoltsMul = UnitQuectovoltsMul;
pub struct UnitFarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFarads {
    #[inline]
    fn clone(&self) -> UnitFarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFarads {
    #[inline]
    fn eq(&self, other: &UnitFarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFarads {
    fn default() -> Self {
        UnitFarads
    }
}
impl Add<UnitFarads> for UnitFarads {
    type Output = UnitFarads;
    #[inline]
    fn add(self, _: UnitFarads) -> Self::Output {
        UnitFarads
    }
}
impl AddAssign<UnitFarads> for UnitFarads {
    #[inline]
    fn add_assign(&mut self, _: UnitFarads) {}
}
impl Sub<UnitFarads> for UnitFarads {
    type Output = UnitFarads;
    #[inline]
    fn sub(self, _: UnitFarads) -> Self::Output {
        UnitFarads
    }
}
impl SubAssign<UnitFarads> for UnitFarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitFarads) {}
}
pub struct UnitFaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFaradsMul {
    #[inline]
    fn clone(&self) -> UnitFaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFaradsMul {
    #[inline]
    fn eq(&self, other: &UnitFaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFaradsMul> for i8 {
    type Output = Quantity<i8, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for i16 {
    type Output = Quantity<i16, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for i32 {
    type Output = Quantity<i32, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for i64 {
    type Output = Quantity<i64, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for i128 {
    type Output = Quantity<i128, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for isize {
    type Output = Quantity<isize, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for u8 {
    type Output = Quantity<u8, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for u16 {
    type Output = Quantity<u16, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for u32 {
    type Output = Quantity<u32, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for u64 {
    type Output = Quantity<u64, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for u128 {
    type Output = Quantity<u128, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for usize {
    type Output = Quantity<usize, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for f32 {
    type Output = Quantity<f32, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
impl Mul<UnitFaradsMul> for f64 {
    type Output = Quantity<f64, UnitFarads>;
    fn mul(self, _: UnitFaradsMul) -> Self::Output {
        Quantity::new(self, UnitFarads)
    }
}
pub struct UnitQuettafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettafarads {
    #[inline]
    fn clone(&self) -> UnitQuettafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettafarads {
    #[inline]
    fn eq(&self, other: &UnitQuettafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettafarads {
    fn default() -> Self {
        UnitQuettafarads
    }
}
impl Add<UnitQuettafarads> for UnitQuettafarads {
    type Output = UnitQuettafarads;
    #[inline]
    fn add(self, _: UnitQuettafarads) -> Self::Output {
        UnitQuettafarads
    }
}
impl AddAssign<UnitQuettafarads> for UnitQuettafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettafarads) {}
}
impl Sub<UnitQuettafarads> for UnitQuettafarads {
    type Output = UnitQuettafarads;
    #[inline]
    fn sub(self, _: UnitQuettafarads) -> Self::Output {
        UnitQuettafarads
    }
}
impl SubAssign<UnitQuettafarads> for UnitQuettafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettafarads) {}
}
pub struct UnitQuettafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettafaradsMul {
    #[inline]
    fn clone(&self) -> UnitQuettafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettafaradsMul> for i8 {
    type Output = Quantity<i8, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for i16 {
    type Output = Quantity<i16, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for i32 {
    type Output = Quantity<i32, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for i64 {
    type Output = Quantity<i64, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for i128 {
    type Output = Quantity<i128, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for isize {
    type Output = Quantity<isize, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for u8 {
    type Output = Quantity<u8, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for u16 {
    type Output = Quantity<u16, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for u32 {
    type Output = Quantity<u32, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for u64 {
    type Output = Quantity<u64, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for u128 {
    type Output = Quantity<u128, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for usize {
    type Output = Quantity<usize, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for f32 {
    type Output = Quantity<f32, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
impl Mul<UnitQuettafaradsMul> for f64 {
    type Output = Quantity<f64, UnitQuettafarads>;
    fn mul(self, _: UnitQuettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuettafarads)
    }
}
pub struct UnitRonnafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnafarads {
    #[inline]
    fn clone(&self) -> UnitRonnafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnafarads {
    #[inline]
    fn eq(&self, other: &UnitRonnafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnafarads {
    fn default() -> Self {
        UnitRonnafarads
    }
}
impl Add<UnitRonnafarads> for UnitRonnafarads {
    type Output = UnitRonnafarads;
    #[inline]
    fn add(self, _: UnitRonnafarads) -> Self::Output {
        UnitRonnafarads
    }
}
impl AddAssign<UnitRonnafarads> for UnitRonnafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnafarads) {}
}
impl Sub<UnitRonnafarads> for UnitRonnafarads {
    type Output = UnitRonnafarads;
    #[inline]
    fn sub(self, _: UnitRonnafarads) -> Self::Output {
        UnitRonnafarads
    }
}
impl SubAssign<UnitRonnafarads> for UnitRonnafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnafarads) {}
}
pub struct UnitRonnafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnafaradsMul {
    #[inline]
    fn clone(&self) -> UnitRonnafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnafaradsMul> for i8 {
    type Output = Quantity<i8, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for i16 {
    type Output = Quantity<i16, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for i32 {
    type Output = Quantity<i32, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for i64 {
    type Output = Quantity<i64, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for i128 {
    type Output = Quantity<i128, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for isize {
    type Output = Quantity<isize, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for u8 {
    type Output = Quantity<u8, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for u16 {
    type Output = Quantity<u16, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for u32 {
    type Output = Quantity<u32, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for u64 {
    type Output = Quantity<u64, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for u128 {
    type Output = Quantity<u128, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for usize {
    type Output = Quantity<usize, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for f32 {
    type Output = Quantity<f32, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
impl Mul<UnitRonnafaradsMul> for f64 {
    type Output = Quantity<f64, UnitRonnafarads>;
    fn mul(self, _: UnitRonnafaradsMul) -> Self::Output {
        Quantity::new(self, UnitRonnafarads)
    }
}
pub struct UnitYottafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottafarads {
    #[inline]
    fn clone(&self) -> UnitYottafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottafarads {
    #[inline]
    fn eq(&self, other: &UnitYottafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottafarads {
    fn default() -> Self {
        UnitYottafarads
    }
}
impl Add<UnitYottafarads> for UnitYottafarads {
    type Output = UnitYottafarads;
    #[inline]
    fn add(self, _: UnitYottafarads) -> Self::Output {
        UnitYottafarads
    }
}
impl AddAssign<UnitYottafarads> for UnitYottafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitYottafarads) {}
}
impl Sub<UnitYottafarads> for UnitYottafarads {
    type Output = UnitYottafarads;
    #[inline]
    fn sub(self, _: UnitYottafarads) -> Self::Output {
        UnitYottafarads
    }
}
impl SubAssign<UnitYottafarads> for UnitYottafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottafarads) {}
}
pub struct UnitYottafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottafaradsMul {
    #[inline]
    fn clone(&self) -> UnitYottafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitYottafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottafaradsMul> for i8 {
    type Output = Quantity<i8, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for i16 {
    type Output = Quantity<i16, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for i32 {
    type Output = Quantity<i32, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for i64 {
    type Output = Quantity<i64, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for i128 {
    type Output = Quantity<i128, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for isize {
    type Output = Quantity<isize, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for u8 {
    type Output = Quantity<u8, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for u16 {
    type Output = Quantity<u16, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for u32 {
    type Output = Quantity<u32, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for u64 {
    type Output = Quantity<u64, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for u128 {
    type Output = Quantity<u128, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for usize {
    type Output = Quantity<usize, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for f32 {
    type Output = Quantity<f32, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
impl Mul<UnitYottafaradsMul> for f64 {
    type Output = Quantity<f64, UnitYottafarads>;
    fn mul(self, _: UnitYottafaradsMul) -> Self::Output {
        Quantity::new(self, UnitYottafarads)
    }
}
pub struct UnitZettafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettafarads {
    #[inline]
    fn clone(&self) -> UnitZettafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettafarads {
    #[inline]
    fn eq(&self, other: &UnitZettafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettafarads {
    fn default() -> Self {
        UnitZettafarads
    }
}
impl Add<UnitZettafarads> for UnitZettafarads {
    type Output = UnitZettafarads;
    #[inline]
    fn add(self, _: UnitZettafarads) -> Self::Output {
        UnitZettafarads
    }
}
impl AddAssign<UnitZettafarads> for UnitZettafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitZettafarads) {}
}
impl Sub<UnitZettafarads> for UnitZettafarads {
    type Output = UnitZettafarads;
    #[inline]
    fn sub(self, _: UnitZettafarads) -> Self::Output {
        UnitZettafarads
    }
}
impl SubAssign<UnitZettafarads> for UnitZettafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettafarads) {}
}
pub struct UnitZettafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettafaradsMul {
    #[inline]
    fn clone(&self) -> UnitZettafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitZettafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettafaradsMul> for i8 {
    type Output = Quantity<i8, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for i16 {
    type Output = Quantity<i16, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for i32 {
    type Output = Quantity<i32, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for i64 {
    type Output = Quantity<i64, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for i128 {
    type Output = Quantity<i128, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for isize {
    type Output = Quantity<isize, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for u8 {
    type Output = Quantity<u8, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for u16 {
    type Output = Quantity<u16, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for u32 {
    type Output = Quantity<u32, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for u64 {
    type Output = Quantity<u64, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for u128 {
    type Output = Quantity<u128, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for usize {
    type Output = Quantity<usize, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for f32 {
    type Output = Quantity<f32, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
impl Mul<UnitZettafaradsMul> for f64 {
    type Output = Quantity<f64, UnitZettafarads>;
    fn mul(self, _: UnitZettafaradsMul) -> Self::Output {
        Quantity::new(self, UnitZettafarads)
    }
}
pub struct UnitExafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExafarads {
    #[inline]
    fn clone(&self) -> UnitExafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExafarads {
    #[inline]
    fn eq(&self, other: &UnitExafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExafarads {
    fn default() -> Self {
        UnitExafarads
    }
}
impl Add<UnitExafarads> for UnitExafarads {
    type Output = UnitExafarads;
    #[inline]
    fn add(self, _: UnitExafarads) -> Self::Output {
        UnitExafarads
    }
}
impl AddAssign<UnitExafarads> for UnitExafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitExafarads) {}
}
impl Sub<UnitExafarads> for UnitExafarads {
    type Output = UnitExafarads;
    #[inline]
    fn sub(self, _: UnitExafarads) -> Self::Output {
        UnitExafarads
    }
}
impl SubAssign<UnitExafarads> for UnitExafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitExafarads) {}
}
pub struct UnitExafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExafaradsMul {
    #[inline]
    fn clone(&self) -> UnitExafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitExafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExafaradsMul> for i8 {
    type Output = Quantity<i8, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for i16 {
    type Output = Quantity<i16, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for i32 {
    type Output = Quantity<i32, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for i64 {
    type Output = Quantity<i64, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for i128 {
    type Output = Quantity<i128, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for isize {
    type Output = Quantity<isize, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for u8 {
    type Output = Quantity<u8, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for u16 {
    type Output = Quantity<u16, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for u32 {
    type Output = Quantity<u32, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for u64 {
    type Output = Quantity<u64, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for u128 {
    type Output = Quantity<u128, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for usize {
    type Output = Quantity<usize, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for f32 {
    type Output = Quantity<f32, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
impl Mul<UnitExafaradsMul> for f64 {
    type Output = Quantity<f64, UnitExafarads>;
    fn mul(self, _: UnitExafaradsMul) -> Self::Output {
        Quantity::new(self, UnitExafarads)
    }
}
pub struct UnitPetafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetafarads {
    #[inline]
    fn clone(&self) -> UnitPetafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetafarads {
    #[inline]
    fn eq(&self, other: &UnitPetafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetafarads {
    fn default() -> Self {
        UnitPetafarads
    }
}
impl Add<UnitPetafarads> for UnitPetafarads {
    type Output = UnitPetafarads;
    #[inline]
    fn add(self, _: UnitPetafarads) -> Self::Output {
        UnitPetafarads
    }
}
impl AddAssign<UnitPetafarads> for UnitPetafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitPetafarads) {}
}
impl Sub<UnitPetafarads> for UnitPetafarads {
    type Output = UnitPetafarads;
    #[inline]
    fn sub(self, _: UnitPetafarads) -> Self::Output {
        UnitPetafarads
    }
}
impl SubAssign<UnitPetafarads> for UnitPetafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetafarads) {}
}
pub struct UnitPetafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetafaradsMul {
    #[inline]
    fn clone(&self) -> UnitPetafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitPetafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetafaradsMul> for i8 {
    type Output = Quantity<i8, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for i16 {
    type Output = Quantity<i16, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for i32 {
    type Output = Quantity<i32, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for i64 {
    type Output = Quantity<i64, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for i128 {
    type Output = Quantity<i128, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for isize {
    type Output = Quantity<isize, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for u8 {
    type Output = Quantity<u8, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for u16 {
    type Output = Quantity<u16, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for u32 {
    type Output = Quantity<u32, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for u64 {
    type Output = Quantity<u64, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for u128 {
    type Output = Quantity<u128, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for usize {
    type Output = Quantity<usize, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for f32 {
    type Output = Quantity<f32, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
impl Mul<UnitPetafaradsMul> for f64 {
    type Output = Quantity<f64, UnitPetafarads>;
    fn mul(self, _: UnitPetafaradsMul) -> Self::Output {
        Quantity::new(self, UnitPetafarads)
    }
}
pub struct UnitTerafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerafarads {
    #[inline]
    fn clone(&self) -> UnitTerafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerafarads {
    #[inline]
    fn eq(&self, other: &UnitTerafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerafarads {
    fn default() -> Self {
        UnitTerafarads
    }
}
impl Add<UnitTerafarads> for UnitTerafarads {
    type Output = UnitTerafarads;
    #[inline]
    fn add(self, _: UnitTerafarads) -> Self::Output {
        UnitTerafarads
    }
}
impl AddAssign<UnitTerafarads> for UnitTerafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitTerafarads) {}
}
impl Sub<UnitTerafarads> for UnitTerafarads {
    type Output = UnitTerafarads;
    #[inline]
    fn sub(self, _: UnitTerafarads) -> Self::Output {
        UnitTerafarads
    }
}
impl SubAssign<UnitTerafarads> for UnitTerafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerafarads) {}
}
pub struct UnitTerafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerafaradsMul {
    #[inline]
    fn clone(&self) -> UnitTerafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitTerafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerafaradsMul> for i8 {
    type Output = Quantity<i8, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for i16 {
    type Output = Quantity<i16, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for i32 {
    type Output = Quantity<i32, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for i64 {
    type Output = Quantity<i64, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for i128 {
    type Output = Quantity<i128, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for isize {
    type Output = Quantity<isize, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for u8 {
    type Output = Quantity<u8, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for u16 {
    type Output = Quantity<u16, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for u32 {
    type Output = Quantity<u32, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for u64 {
    type Output = Quantity<u64, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for u128 {
    type Output = Quantity<u128, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for usize {
    type Output = Quantity<usize, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for f32 {
    type Output = Quantity<f32, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
impl Mul<UnitTerafaradsMul> for f64 {
    type Output = Quantity<f64, UnitTerafarads>;
    fn mul(self, _: UnitTerafaradsMul) -> Self::Output {
        Quantity::new(self, UnitTerafarads)
    }
}
pub struct UnitGigafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigafarads {
    #[inline]
    fn clone(&self) -> UnitGigafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigafarads {
    #[inline]
    fn eq(&self, other: &UnitGigafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigafarads {
    fn default() -> Self {
        UnitGigafarads
    }
}
impl Add<UnitGigafarads> for UnitGigafarads {
    type Output = UnitGigafarads;
    #[inline]
    fn add(self, _: UnitGigafarads) -> Self::Output {
        UnitGigafarads
    }
}
impl AddAssign<UnitGigafarads> for UnitGigafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitGigafarads) {}
}
impl Sub<UnitGigafarads> for UnitGigafarads {
    type Output = UnitGigafarads;
    #[inline]
    fn sub(self, _: UnitGigafarads) -> Self::Output {
        UnitGigafarads
    }
}
impl SubAssign<UnitGigafarads> for UnitGigafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigafarads) {}
}
pub struct UnitGigafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigafaradsMul {
    #[inline]
    fn clone(&self) -> UnitGigafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitGigafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigafaradsMul> for i8 {
    type Output = Quantity<i8, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for i16 {
    type Output = Quantity<i16, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for i32 {
    type Output = Quantity<i32, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for i64 {
    type Output = Quantity<i64, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for i128 {
    type Output = Quantity<i128, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for isize {
    type Output = Quantity<isize, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for u8 {
    type Output = Quantity<u8, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for u16 {
    type Output = Quantity<u16, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for u32 {
    type Output = Quantity<u32, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for u64 {
    type Output = Quantity<u64, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for u128 {
    type Output = Quantity<u128, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for usize {
    type Output = Quantity<usize, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for f32 {
    type Output = Quantity<f32, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
impl Mul<UnitGigafaradsMul> for f64 {
    type Output = Quantity<f64, UnitGigafarads>;
    fn mul(self, _: UnitGigafaradsMul) -> Self::Output {
        Quantity::new(self, UnitGigafarads)
    }
}
pub struct UnitMegafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegafarads {
    #[inline]
    fn clone(&self) -> UnitMegafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegafarads {
    #[inline]
    fn eq(&self, other: &UnitMegafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegafarads {
    fn default() -> Self {
        UnitMegafarads
    }
}
impl Add<UnitMegafarads> for UnitMegafarads {
    type Output = UnitMegafarads;
    #[inline]
    fn add(self, _: UnitMegafarads) -> Self::Output {
        UnitMegafarads
    }
}
impl AddAssign<UnitMegafarads> for UnitMegafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitMegafarads) {}
}
impl Sub<UnitMegafarads> for UnitMegafarads {
    type Output = UnitMegafarads;
    #[inline]
    fn sub(self, _: UnitMegafarads) -> Self::Output {
        UnitMegafarads
    }
}
impl SubAssign<UnitMegafarads> for UnitMegafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegafarads) {}
}
pub struct UnitMegafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegafaradsMul {
    #[inline]
    fn clone(&self) -> UnitMegafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitMegafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegafaradsMul> for i8 {
    type Output = Quantity<i8, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for i16 {
    type Output = Quantity<i16, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for i32 {
    type Output = Quantity<i32, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for i64 {
    type Output = Quantity<i64, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for i128 {
    type Output = Quantity<i128, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for isize {
    type Output = Quantity<isize, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for u8 {
    type Output = Quantity<u8, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for u16 {
    type Output = Quantity<u16, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for u32 {
    type Output = Quantity<u32, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for u64 {
    type Output = Quantity<u64, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for u128 {
    type Output = Quantity<u128, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for usize {
    type Output = Quantity<usize, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for f32 {
    type Output = Quantity<f32, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
impl Mul<UnitMegafaradsMul> for f64 {
    type Output = Quantity<f64, UnitMegafarads>;
    fn mul(self, _: UnitMegafaradsMul) -> Self::Output {
        Quantity::new(self, UnitMegafarads)
    }
}
pub struct UnitKilofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilofarads {
    #[inline]
    fn clone(&self) -> UnitKilofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilofarads {
    #[inline]
    fn eq(&self, other: &UnitKilofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilofarads {
    fn default() -> Self {
        UnitKilofarads
    }
}
impl Add<UnitKilofarads> for UnitKilofarads {
    type Output = UnitKilofarads;
    #[inline]
    fn add(self, _: UnitKilofarads) -> Self::Output {
        UnitKilofarads
    }
}
impl AddAssign<UnitKilofarads> for UnitKilofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitKilofarads) {}
}
impl Sub<UnitKilofarads> for UnitKilofarads {
    type Output = UnitKilofarads;
    #[inline]
    fn sub(self, _: UnitKilofarads) -> Self::Output {
        UnitKilofarads
    }
}
impl SubAssign<UnitKilofarads> for UnitKilofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilofarads) {}
}
pub struct UnitKilofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilofaradsMul {
    #[inline]
    fn clone(&self) -> UnitKilofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitKilofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilofaradsMul> for i8 {
    type Output = Quantity<i8, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for i16 {
    type Output = Quantity<i16, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for i32 {
    type Output = Quantity<i32, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for i64 {
    type Output = Quantity<i64, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for i128 {
    type Output = Quantity<i128, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for isize {
    type Output = Quantity<isize, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for u8 {
    type Output = Quantity<u8, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for u16 {
    type Output = Quantity<u16, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for u32 {
    type Output = Quantity<u32, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for u64 {
    type Output = Quantity<u64, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for u128 {
    type Output = Quantity<u128, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for usize {
    type Output = Quantity<usize, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for f32 {
    type Output = Quantity<f32, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
impl Mul<UnitKilofaradsMul> for f64 {
    type Output = Quantity<f64, UnitKilofarads>;
    fn mul(self, _: UnitKilofaradsMul) -> Self::Output {
        Quantity::new(self, UnitKilofarads)
    }
}
pub struct UnitHectofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectofarads {
    #[inline]
    fn clone(&self) -> UnitHectofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectofarads {
    #[inline]
    fn eq(&self, other: &UnitHectofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectofarads {
    fn default() -> Self {
        UnitHectofarads
    }
}
impl Add<UnitHectofarads> for UnitHectofarads {
    type Output = UnitHectofarads;
    #[inline]
    fn add(self, _: UnitHectofarads) -> Self::Output {
        UnitHectofarads
    }
}
impl AddAssign<UnitHectofarads> for UnitHectofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitHectofarads) {}
}
impl Sub<UnitHectofarads> for UnitHectofarads {
    type Output = UnitHectofarads;
    #[inline]
    fn sub(self, _: UnitHectofarads) -> Self::Output {
        UnitHectofarads
    }
}
impl SubAssign<UnitHectofarads> for UnitHectofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectofarads) {}
}
pub struct UnitHectofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectofaradsMul {
    #[inline]
    fn clone(&self) -> UnitHectofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitHectofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectofaradsMul> for i8 {
    type Output = Quantity<i8, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for i16 {
    type Output = Quantity<i16, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for i32 {
    type Output = Quantity<i32, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for i64 {
    type Output = Quantity<i64, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for i128 {
    type Output = Quantity<i128, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for isize {
    type Output = Quantity<isize, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for u8 {
    type Output = Quantity<u8, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for u16 {
    type Output = Quantity<u16, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for u32 {
    type Output = Quantity<u32, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for u64 {
    type Output = Quantity<u64, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for u128 {
    type Output = Quantity<u128, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for usize {
    type Output = Quantity<usize, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for f32 {
    type Output = Quantity<f32, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
impl Mul<UnitHectofaradsMul> for f64 {
    type Output = Quantity<f64, UnitHectofarads>;
    fn mul(self, _: UnitHectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitHectofarads)
    }
}
pub struct UnitDecafarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecafarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecafarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecafarads {
    #[inline]
    fn clone(&self) -> UnitDecafarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecafarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecafarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecafarads {
    #[inline]
    fn eq(&self, other: &UnitDecafarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecafarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecafarads {
    fn default() -> Self {
        UnitDecafarads
    }
}
impl Add<UnitDecafarads> for UnitDecafarads {
    type Output = UnitDecafarads;
    #[inline]
    fn add(self, _: UnitDecafarads) -> Self::Output {
        UnitDecafarads
    }
}
impl AddAssign<UnitDecafarads> for UnitDecafarads {
    #[inline]
    fn add_assign(&mut self, _: UnitDecafarads) {}
}
impl Sub<UnitDecafarads> for UnitDecafarads {
    type Output = UnitDecafarads;
    #[inline]
    fn sub(self, _: UnitDecafarads) -> Self::Output {
        UnitDecafarads
    }
}
impl SubAssign<UnitDecafarads> for UnitDecafarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecafarads) {}
}
pub struct UnitDecafaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecafaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecafaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecafaradsMul {
    #[inline]
    fn clone(&self) -> UnitDecafaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecafaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecafaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecafaradsMul {
    #[inline]
    fn eq(&self, other: &UnitDecafaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecafaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecafaradsMul> for i8 {
    type Output = Quantity<i8, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for i16 {
    type Output = Quantity<i16, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for i32 {
    type Output = Quantity<i32, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for i64 {
    type Output = Quantity<i64, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for i128 {
    type Output = Quantity<i128, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for isize {
    type Output = Quantity<isize, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for u8 {
    type Output = Quantity<u8, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for u16 {
    type Output = Quantity<u16, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for u32 {
    type Output = Quantity<u32, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for u64 {
    type Output = Quantity<u64, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for u128 {
    type Output = Quantity<u128, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for usize {
    type Output = Quantity<usize, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for f32 {
    type Output = Quantity<f32, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
impl Mul<UnitDecafaradsMul> for f64 {
    type Output = Quantity<f64, UnitDecafarads>;
    fn mul(self, _: UnitDecafaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecafarads)
    }
}
pub struct UnitDecifarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecifarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecifarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecifarads {
    #[inline]
    fn clone(&self) -> UnitDecifarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecifarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecifarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecifarads {
    #[inline]
    fn eq(&self, other: &UnitDecifarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecifarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecifarads {
    fn default() -> Self {
        UnitDecifarads
    }
}
impl Add<UnitDecifarads> for UnitDecifarads {
    type Output = UnitDecifarads;
    #[inline]
    fn add(self, _: UnitDecifarads) -> Self::Output {
        UnitDecifarads
    }
}
impl AddAssign<UnitDecifarads> for UnitDecifarads {
    #[inline]
    fn add_assign(&mut self, _: UnitDecifarads) {}
}
impl Sub<UnitDecifarads> for UnitDecifarads {
    type Output = UnitDecifarads;
    #[inline]
    fn sub(self, _: UnitDecifarads) -> Self::Output {
        UnitDecifarads
    }
}
impl SubAssign<UnitDecifarads> for UnitDecifarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecifarads) {}
}
pub struct UnitDecifaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecifaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecifaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecifaradsMul {
    #[inline]
    fn clone(&self) -> UnitDecifaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecifaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecifaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecifaradsMul {
    #[inline]
    fn eq(&self, other: &UnitDecifaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecifaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecifaradsMul> for i8 {
    type Output = Quantity<i8, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for i16 {
    type Output = Quantity<i16, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for i32 {
    type Output = Quantity<i32, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for i64 {
    type Output = Quantity<i64, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for i128 {
    type Output = Quantity<i128, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for isize {
    type Output = Quantity<isize, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for u8 {
    type Output = Quantity<u8, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for u16 {
    type Output = Quantity<u16, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for u32 {
    type Output = Quantity<u32, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for u64 {
    type Output = Quantity<u64, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for u128 {
    type Output = Quantity<u128, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for usize {
    type Output = Quantity<usize, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for f32 {
    type Output = Quantity<f32, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
impl Mul<UnitDecifaradsMul> for f64 {
    type Output = Quantity<f64, UnitDecifarads>;
    fn mul(self, _: UnitDecifaradsMul) -> Self::Output {
        Quantity::new(self, UnitDecifarads)
    }
}
pub struct UnitCentifarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentifarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentifarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentifarads {
    #[inline]
    fn clone(&self) -> UnitCentifarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentifarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentifarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentifarads {
    #[inline]
    fn eq(&self, other: &UnitCentifarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentifarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentifarads {
    fn default() -> Self {
        UnitCentifarads
    }
}
impl Add<UnitCentifarads> for UnitCentifarads {
    type Output = UnitCentifarads;
    #[inline]
    fn add(self, _: UnitCentifarads) -> Self::Output {
        UnitCentifarads
    }
}
impl AddAssign<UnitCentifarads> for UnitCentifarads {
    #[inline]
    fn add_assign(&mut self, _: UnitCentifarads) {}
}
impl Sub<UnitCentifarads> for UnitCentifarads {
    type Output = UnitCentifarads;
    #[inline]
    fn sub(self, _: UnitCentifarads) -> Self::Output {
        UnitCentifarads
    }
}
impl SubAssign<UnitCentifarads> for UnitCentifarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentifarads) {}
}
pub struct UnitCentifaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentifaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentifaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentifaradsMul {
    #[inline]
    fn clone(&self) -> UnitCentifaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentifaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentifaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentifaradsMul {
    #[inline]
    fn eq(&self, other: &UnitCentifaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentifaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentifaradsMul> for i8 {
    type Output = Quantity<i8, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for i16 {
    type Output = Quantity<i16, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for i32 {
    type Output = Quantity<i32, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for i64 {
    type Output = Quantity<i64, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for i128 {
    type Output = Quantity<i128, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for isize {
    type Output = Quantity<isize, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for u8 {
    type Output = Quantity<u8, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for u16 {
    type Output = Quantity<u16, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for u32 {
    type Output = Quantity<u32, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for u64 {
    type Output = Quantity<u64, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for u128 {
    type Output = Quantity<u128, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for usize {
    type Output = Quantity<usize, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for f32 {
    type Output = Quantity<f32, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
impl Mul<UnitCentifaradsMul> for f64 {
    type Output = Quantity<f64, UnitCentifarads>;
    fn mul(self, _: UnitCentifaradsMul) -> Self::Output {
        Quantity::new(self, UnitCentifarads)
    }
}
pub struct UnitMillifarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillifarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillifarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillifarads {
    #[inline]
    fn clone(&self) -> UnitMillifarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillifarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillifarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillifarads {
    #[inline]
    fn eq(&self, other: &UnitMillifarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillifarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillifarads {
    fn default() -> Self {
        UnitMillifarads
    }
}
impl Add<UnitMillifarads> for UnitMillifarads {
    type Output = UnitMillifarads;
    #[inline]
    fn add(self, _: UnitMillifarads) -> Self::Output {
        UnitMillifarads
    }
}
impl AddAssign<UnitMillifarads> for UnitMillifarads {
    #[inline]
    fn add_assign(&mut self, _: UnitMillifarads) {}
}
impl Sub<UnitMillifarads> for UnitMillifarads {
    type Output = UnitMillifarads;
    #[inline]
    fn sub(self, _: UnitMillifarads) -> Self::Output {
        UnitMillifarads
    }
}
impl SubAssign<UnitMillifarads> for UnitMillifarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillifarads) {}
}
pub struct UnitMillifaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillifaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillifaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillifaradsMul {
    #[inline]
    fn clone(&self) -> UnitMillifaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillifaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillifaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillifaradsMul {
    #[inline]
    fn eq(&self, other: &UnitMillifaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillifaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillifaradsMul> for i8 {
    type Output = Quantity<i8, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for i16 {
    type Output = Quantity<i16, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for i32 {
    type Output = Quantity<i32, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for i64 {
    type Output = Quantity<i64, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for i128 {
    type Output = Quantity<i128, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for isize {
    type Output = Quantity<isize, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for u8 {
    type Output = Quantity<u8, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for u16 {
    type Output = Quantity<u16, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for u32 {
    type Output = Quantity<u32, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for u64 {
    type Output = Quantity<u64, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for u128 {
    type Output = Quantity<u128, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for usize {
    type Output = Quantity<usize, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for f32 {
    type Output = Quantity<f32, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
impl Mul<UnitMillifaradsMul> for f64 {
    type Output = Quantity<f64, UnitMillifarads>;
    fn mul(self, _: UnitMillifaradsMul) -> Self::Output {
        Quantity::new(self, UnitMillifarads)
    }
}
pub struct UnitMicrofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrofarads {
    #[inline]
    fn clone(&self) -> UnitMicrofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrofarads {
    #[inline]
    fn eq(&self, other: &UnitMicrofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrofarads {
    fn default() -> Self {
        UnitMicrofarads
    }
}
impl Add<UnitMicrofarads> for UnitMicrofarads {
    type Output = UnitMicrofarads;
    #[inline]
    fn add(self, _: UnitMicrofarads) -> Self::Output {
        UnitMicrofarads
    }
}
impl AddAssign<UnitMicrofarads> for UnitMicrofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrofarads) {}
}
impl Sub<UnitMicrofarads> for UnitMicrofarads {
    type Output = UnitMicrofarads;
    #[inline]
    fn sub(self, _: UnitMicrofarads) -> Self::Output {
        UnitMicrofarads
    }
}
impl SubAssign<UnitMicrofarads> for UnitMicrofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrofarads) {}
}
pub struct UnitMicrofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrofaradsMul {
    #[inline]
    fn clone(&self) -> UnitMicrofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrofaradsMul> for i8 {
    type Output = Quantity<i8, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for i16 {
    type Output = Quantity<i16, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for i32 {
    type Output = Quantity<i32, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for i64 {
    type Output = Quantity<i64, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for i128 {
    type Output = Quantity<i128, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for isize {
    type Output = Quantity<isize, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for u8 {
    type Output = Quantity<u8, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for u16 {
    type Output = Quantity<u16, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for u32 {
    type Output = Quantity<u32, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for u64 {
    type Output = Quantity<u64, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for u128 {
    type Output = Quantity<u128, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for usize {
    type Output = Quantity<usize, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for f32 {
    type Output = Quantity<f32, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
impl Mul<UnitMicrofaradsMul> for f64 {
    type Output = Quantity<f64, UnitMicrofarads>;
    fn mul(self, _: UnitMicrofaradsMul) -> Self::Output {
        Quantity::new(self, UnitMicrofarads)
    }
}
pub struct UnitNanofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanofarads {
    #[inline]
    fn clone(&self) -> UnitNanofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanofarads {
    #[inline]
    fn eq(&self, other: &UnitNanofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanofarads {
    fn default() -> Self {
        UnitNanofarads
    }
}
impl Add<UnitNanofarads> for UnitNanofarads {
    type Output = UnitNanofarads;
    #[inline]
    fn add(self, _: UnitNanofarads) -> Self::Output {
        UnitNanofarads
    }
}
impl AddAssign<UnitNanofarads> for UnitNanofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitNanofarads) {}
}
impl Sub<UnitNanofarads> for UnitNanofarads {
    type Output = UnitNanofarads;
    #[inline]
    fn sub(self, _: UnitNanofarads) -> Self::Output {
        UnitNanofarads
    }
}
impl SubAssign<UnitNanofarads> for UnitNanofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanofarads) {}
}
pub struct UnitNanofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanofaradsMul {
    #[inline]
    fn clone(&self) -> UnitNanofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitNanofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanofaradsMul> for i8 {
    type Output = Quantity<i8, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for i16 {
    type Output = Quantity<i16, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for i32 {
    type Output = Quantity<i32, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for i64 {
    type Output = Quantity<i64, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for i128 {
    type Output = Quantity<i128, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for isize {
    type Output = Quantity<isize, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for u8 {
    type Output = Quantity<u8, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for u16 {
    type Output = Quantity<u16, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for u32 {
    type Output = Quantity<u32, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for u64 {
    type Output = Quantity<u64, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for u128 {
    type Output = Quantity<u128, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for usize {
    type Output = Quantity<usize, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for f32 {
    type Output = Quantity<f32, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
impl Mul<UnitNanofaradsMul> for f64 {
    type Output = Quantity<f64, UnitNanofarads>;
    fn mul(self, _: UnitNanofaradsMul) -> Self::Output {
        Quantity::new(self, UnitNanofarads)
    }
}
pub struct UnitPicofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicofarads {
    #[inline]
    fn clone(&self) -> UnitPicofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicofarads {
    #[inline]
    fn eq(&self, other: &UnitPicofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicofarads {
    fn default() -> Self {
        UnitPicofarads
    }
}
impl Add<UnitPicofarads> for UnitPicofarads {
    type Output = UnitPicofarads;
    #[inline]
    fn add(self, _: UnitPicofarads) -> Self::Output {
        UnitPicofarads
    }
}
impl AddAssign<UnitPicofarads> for UnitPicofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitPicofarads) {}
}
impl Sub<UnitPicofarads> for UnitPicofarads {
    type Output = UnitPicofarads;
    #[inline]
    fn sub(self, _: UnitPicofarads) -> Self::Output {
        UnitPicofarads
    }
}
impl SubAssign<UnitPicofarads> for UnitPicofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicofarads) {}
}
pub struct UnitPicofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicofaradsMul {
    #[inline]
    fn clone(&self) -> UnitPicofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitPicofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicofaradsMul> for i8 {
    type Output = Quantity<i8, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for i16 {
    type Output = Quantity<i16, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for i32 {
    type Output = Quantity<i32, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for i64 {
    type Output = Quantity<i64, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for i128 {
    type Output = Quantity<i128, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for isize {
    type Output = Quantity<isize, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for u8 {
    type Output = Quantity<u8, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for u16 {
    type Output = Quantity<u16, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for u32 {
    type Output = Quantity<u32, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for u64 {
    type Output = Quantity<u64, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for u128 {
    type Output = Quantity<u128, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for usize {
    type Output = Quantity<usize, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for f32 {
    type Output = Quantity<f32, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
impl Mul<UnitPicofaradsMul> for f64 {
    type Output = Quantity<f64, UnitPicofarads>;
    fn mul(self, _: UnitPicofaradsMul) -> Self::Output {
        Quantity::new(self, UnitPicofarads)
    }
}
pub struct UnitFemtofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtofarads {
    #[inline]
    fn clone(&self) -> UnitFemtofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtofarads {
    #[inline]
    fn eq(&self, other: &UnitFemtofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtofarads {
    fn default() -> Self {
        UnitFemtofarads
    }
}
impl Add<UnitFemtofarads> for UnitFemtofarads {
    type Output = UnitFemtofarads;
    #[inline]
    fn add(self, _: UnitFemtofarads) -> Self::Output {
        UnitFemtofarads
    }
}
impl AddAssign<UnitFemtofarads> for UnitFemtofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtofarads) {}
}
impl Sub<UnitFemtofarads> for UnitFemtofarads {
    type Output = UnitFemtofarads;
    #[inline]
    fn sub(self, _: UnitFemtofarads) -> Self::Output {
        UnitFemtofarads
    }
}
impl SubAssign<UnitFemtofarads> for UnitFemtofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtofarads) {}
}
pub struct UnitFemtofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtofaradsMul {
    #[inline]
    fn clone(&self) -> UnitFemtofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtofaradsMul> for i8 {
    type Output = Quantity<i8, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for i16 {
    type Output = Quantity<i16, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for i32 {
    type Output = Quantity<i32, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for i64 {
    type Output = Quantity<i64, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for i128 {
    type Output = Quantity<i128, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for isize {
    type Output = Quantity<isize, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for u8 {
    type Output = Quantity<u8, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for u16 {
    type Output = Quantity<u16, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for u32 {
    type Output = Quantity<u32, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for u64 {
    type Output = Quantity<u64, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for u128 {
    type Output = Quantity<u128, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for usize {
    type Output = Quantity<usize, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for f32 {
    type Output = Quantity<f32, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
impl Mul<UnitFemtofaradsMul> for f64 {
    type Output = Quantity<f64, UnitFemtofarads>;
    fn mul(self, _: UnitFemtofaradsMul) -> Self::Output {
        Quantity::new(self, UnitFemtofarads)
    }
}
pub struct UnitAttofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttofarads {
    #[inline]
    fn clone(&self) -> UnitAttofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttofarads {
    #[inline]
    fn eq(&self, other: &UnitAttofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttofarads {
    fn default() -> Self {
        UnitAttofarads
    }
}
impl Add<UnitAttofarads> for UnitAttofarads {
    type Output = UnitAttofarads;
    #[inline]
    fn add(self, _: UnitAttofarads) -> Self::Output {
        UnitAttofarads
    }
}
impl AddAssign<UnitAttofarads> for UnitAttofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitAttofarads) {}
}
impl Sub<UnitAttofarads> for UnitAttofarads {
    type Output = UnitAttofarads;
    #[inline]
    fn sub(self, _: UnitAttofarads) -> Self::Output {
        UnitAttofarads
    }
}
impl SubAssign<UnitAttofarads> for UnitAttofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttofarads) {}
}
pub struct UnitAttofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttofaradsMul {
    #[inline]
    fn clone(&self) -> UnitAttofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitAttofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttofaradsMul> for i8 {
    type Output = Quantity<i8, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for i16 {
    type Output = Quantity<i16, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for i32 {
    type Output = Quantity<i32, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for i64 {
    type Output = Quantity<i64, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for i128 {
    type Output = Quantity<i128, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for isize {
    type Output = Quantity<isize, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for u8 {
    type Output = Quantity<u8, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for u16 {
    type Output = Quantity<u16, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for u32 {
    type Output = Quantity<u32, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for u64 {
    type Output = Quantity<u64, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for u128 {
    type Output = Quantity<u128, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for usize {
    type Output = Quantity<usize, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for f32 {
    type Output = Quantity<f32, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
impl Mul<UnitAttofaradsMul> for f64 {
    type Output = Quantity<f64, UnitAttofarads>;
    fn mul(self, _: UnitAttofaradsMul) -> Self::Output {
        Quantity::new(self, UnitAttofarads)
    }
}
pub struct UnitZeptofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptofarads {
    #[inline]
    fn clone(&self) -> UnitZeptofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptofarads {
    #[inline]
    fn eq(&self, other: &UnitZeptofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptofarads {
    fn default() -> Self {
        UnitZeptofarads
    }
}
impl Add<UnitZeptofarads> for UnitZeptofarads {
    type Output = UnitZeptofarads;
    #[inline]
    fn add(self, _: UnitZeptofarads) -> Self::Output {
        UnitZeptofarads
    }
}
impl AddAssign<UnitZeptofarads> for UnitZeptofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptofarads) {}
}
impl Sub<UnitZeptofarads> for UnitZeptofarads {
    type Output = UnitZeptofarads;
    #[inline]
    fn sub(self, _: UnitZeptofarads) -> Self::Output {
        UnitZeptofarads
    }
}
impl SubAssign<UnitZeptofarads> for UnitZeptofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptofarads) {}
}
pub struct UnitZeptofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptofaradsMul {
    #[inline]
    fn clone(&self) -> UnitZeptofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptofaradsMul> for i8 {
    type Output = Quantity<i8, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for i16 {
    type Output = Quantity<i16, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for i32 {
    type Output = Quantity<i32, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for i64 {
    type Output = Quantity<i64, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for i128 {
    type Output = Quantity<i128, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for isize {
    type Output = Quantity<isize, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for u8 {
    type Output = Quantity<u8, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for u16 {
    type Output = Quantity<u16, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for u32 {
    type Output = Quantity<u32, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for u64 {
    type Output = Quantity<u64, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for u128 {
    type Output = Quantity<u128, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for usize {
    type Output = Quantity<usize, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for f32 {
    type Output = Quantity<f32, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
impl Mul<UnitZeptofaradsMul> for f64 {
    type Output = Quantity<f64, UnitZeptofarads>;
    fn mul(self, _: UnitZeptofaradsMul) -> Self::Output {
        Quantity::new(self, UnitZeptofarads)
    }
}
pub struct UnitYoctofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctofarads {
    #[inline]
    fn clone(&self) -> UnitYoctofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctofarads {
    #[inline]
    fn eq(&self, other: &UnitYoctofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctofarads {
    fn default() -> Self {
        UnitYoctofarads
    }
}
impl Add<UnitYoctofarads> for UnitYoctofarads {
    type Output = UnitYoctofarads;
    #[inline]
    fn add(self, _: UnitYoctofarads) -> Self::Output {
        UnitYoctofarads
    }
}
impl AddAssign<UnitYoctofarads> for UnitYoctofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctofarads) {}
}
impl Sub<UnitYoctofarads> for UnitYoctofarads {
    type Output = UnitYoctofarads;
    #[inline]
    fn sub(self, _: UnitYoctofarads) -> Self::Output {
        UnitYoctofarads
    }
}
impl SubAssign<UnitYoctofarads> for UnitYoctofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctofarads) {}
}
pub struct UnitYoctofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctofaradsMul {
    #[inline]
    fn clone(&self) -> UnitYoctofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctofaradsMul> for i8 {
    type Output = Quantity<i8, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for i16 {
    type Output = Quantity<i16, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for i32 {
    type Output = Quantity<i32, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for i64 {
    type Output = Quantity<i64, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for i128 {
    type Output = Quantity<i128, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for isize {
    type Output = Quantity<isize, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for u8 {
    type Output = Quantity<u8, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for u16 {
    type Output = Quantity<u16, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for u32 {
    type Output = Quantity<u32, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for u64 {
    type Output = Quantity<u64, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for u128 {
    type Output = Quantity<u128, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for usize {
    type Output = Quantity<usize, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for f32 {
    type Output = Quantity<f32, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
impl Mul<UnitYoctofaradsMul> for f64 {
    type Output = Quantity<f64, UnitYoctofarads>;
    fn mul(self, _: UnitYoctofaradsMul) -> Self::Output {
        Quantity::new(self, UnitYoctofarads)
    }
}
pub struct UnitRontofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontofarads {
    #[inline]
    fn clone(&self) -> UnitRontofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontofarads {
    #[inline]
    fn eq(&self, other: &UnitRontofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontofarads {
    fn default() -> Self {
        UnitRontofarads
    }
}
impl Add<UnitRontofarads> for UnitRontofarads {
    type Output = UnitRontofarads;
    #[inline]
    fn add(self, _: UnitRontofarads) -> Self::Output {
        UnitRontofarads
    }
}
impl AddAssign<UnitRontofarads> for UnitRontofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitRontofarads) {}
}
impl Sub<UnitRontofarads> for UnitRontofarads {
    type Output = UnitRontofarads;
    #[inline]
    fn sub(self, _: UnitRontofarads) -> Self::Output {
        UnitRontofarads
    }
}
impl SubAssign<UnitRontofarads> for UnitRontofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontofarads) {}
}
pub struct UnitRontofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontofaradsMul {
    #[inline]
    fn clone(&self) -> UnitRontofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitRontofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontofaradsMul> for i8 {
    type Output = Quantity<i8, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for i16 {
    type Output = Quantity<i16, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for i32 {
    type Output = Quantity<i32, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for i64 {
    type Output = Quantity<i64, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for i128 {
    type Output = Quantity<i128, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for isize {
    type Output = Quantity<isize, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for u8 {
    type Output = Quantity<u8, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for u16 {
    type Output = Quantity<u16, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for u32 {
    type Output = Quantity<u32, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for u64 {
    type Output = Quantity<u64, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for u128 {
    type Output = Quantity<u128, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for usize {
    type Output = Quantity<usize, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for f32 {
    type Output = Quantity<f32, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
impl Mul<UnitRontofaradsMul> for f64 {
    type Output = Quantity<f64, UnitRontofarads>;
    fn mul(self, _: UnitRontofaradsMul) -> Self::Output {
        Quantity::new(self, UnitRontofarads)
    }
}
pub struct UnitQuectofarads;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectofarads {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectofarads")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectofarads {
    #[inline]
    fn clone(&self) -> UnitQuectofarads {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectofarads {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectofarads {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectofarads {
    #[inline]
    fn eq(&self, other: &UnitQuectofarads) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectofarads {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectofarads {
    fn default() -> Self {
        UnitQuectofarads
    }
}
impl Add<UnitQuectofarads> for UnitQuectofarads {
    type Output = UnitQuectofarads;
    #[inline]
    fn add(self, _: UnitQuectofarads) -> Self::Output {
        UnitQuectofarads
    }
}
impl AddAssign<UnitQuectofarads> for UnitQuectofarads {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectofarads) {}
}
impl Sub<UnitQuectofarads> for UnitQuectofarads {
    type Output = UnitQuectofarads;
    #[inline]
    fn sub(self, _: UnitQuectofarads) -> Self::Output {
        UnitQuectofarads
    }
}
impl SubAssign<UnitQuectofarads> for UnitQuectofarads {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectofarads) {}
}
pub struct UnitQuectofaradsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectofaradsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectofaradsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectofaradsMul {
    #[inline]
    fn clone(&self) -> UnitQuectofaradsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectofaradsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectofaradsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectofaradsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectofaradsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectofaradsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectofaradsMul> for i8 {
    type Output = Quantity<i8, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for i16 {
    type Output = Quantity<i16, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for i32 {
    type Output = Quantity<i32, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for i64 {
    type Output = Quantity<i64, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for i128 {
    type Output = Quantity<i128, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for isize {
    type Output = Quantity<isize, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for u8 {
    type Output = Quantity<u8, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for u16 {
    type Output = Quantity<u16, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for u32 {
    type Output = Quantity<u32, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for u64 {
    type Output = Quantity<u64, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for u128 {
    type Output = Quantity<u128, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for usize {
    type Output = Quantity<usize, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for f32 {
    type Output = Quantity<f32, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
impl Mul<UnitQuectofaradsMul> for f64 {
    type Output = Quantity<f64, UnitQuectofarads>;
    fn mul(self, _: UnitQuectofaradsMul) -> Self::Output {
        Quantity::new(self, UnitQuectofarads)
    }
}
pub type Farads<T> = Quantity<T, UnitFarads>;
#[allow(non_upper_case_globals)]
pub static Farads: UnitFaradsMul = UnitFaradsMul;
pub type Quettafarads<T> = Quantity<T, UnitQuettafarads>;
#[allow(non_upper_case_globals)]
pub static Quettafarads: UnitQuettafaradsMul = UnitQuettafaradsMul;
pub type Ronnafarads<T> = Quantity<T, UnitRonnafarads>;
#[allow(non_upper_case_globals)]
pub static Ronnafarads: UnitRonnafaradsMul = UnitRonnafaradsMul;
pub type Yottafarads<T> = Quantity<T, UnitYottafarads>;
#[allow(non_upper_case_globals)]
pub static Yottafarads: UnitYottafaradsMul = UnitYottafaradsMul;
pub type Zettafarads<T> = Quantity<T, UnitZettafarads>;
#[allow(non_upper_case_globals)]
pub static Zettafarads: UnitZettafaradsMul = UnitZettafaradsMul;
pub type Exafarads<T> = Quantity<T, UnitExafarads>;
#[allow(non_upper_case_globals)]
pub static Exafarads: UnitExafaradsMul = UnitExafaradsMul;
pub type Petafarads<T> = Quantity<T, UnitPetafarads>;
#[allow(non_upper_case_globals)]
pub static Petafarads: UnitPetafaradsMul = UnitPetafaradsMul;
pub type Terafarads<T> = Quantity<T, UnitTerafarads>;
#[allow(non_upper_case_globals)]
pub static Terafarads: UnitTerafaradsMul = UnitTerafaradsMul;
pub type Gigafarads<T> = Quantity<T, UnitGigafarads>;
#[allow(non_upper_case_globals)]
pub static Gigafarads: UnitGigafaradsMul = UnitGigafaradsMul;
pub type Megafarads<T> = Quantity<T, UnitMegafarads>;
#[allow(non_upper_case_globals)]
pub static Megafarads: UnitMegafaradsMul = UnitMegafaradsMul;
pub type Kilofarads<T> = Quantity<T, UnitKilofarads>;
#[allow(non_upper_case_globals)]
pub static Kilofarads: UnitKilofaradsMul = UnitKilofaradsMul;
pub type Hectofarads<T> = Quantity<T, UnitHectofarads>;
#[allow(non_upper_case_globals)]
pub static Hectofarads: UnitHectofaradsMul = UnitHectofaradsMul;
pub type Decafarads<T> = Quantity<T, UnitDecafarads>;
#[allow(non_upper_case_globals)]
pub static Decafarads: UnitDecafaradsMul = UnitDecafaradsMul;
pub type Decifarads<T> = Quantity<T, UnitDecifarads>;
#[allow(non_upper_case_globals)]
pub static Decifarads: UnitDecifaradsMul = UnitDecifaradsMul;
pub type Centifarads<T> = Quantity<T, UnitCentifarads>;
#[allow(non_upper_case_globals)]
pub static Centifarads: UnitCentifaradsMul = UnitCentifaradsMul;
pub type Millifarads<T> = Quantity<T, UnitMillifarads>;
#[allow(non_upper_case_globals)]
pub static Millifarads: UnitMillifaradsMul = UnitMillifaradsMul;
pub type Microfarads<T> = Quantity<T, UnitMicrofarads>;
#[allow(non_upper_case_globals)]
pub static Microfarads: UnitMicrofaradsMul = UnitMicrofaradsMul;
pub type Nanofarads<T> = Quantity<T, UnitNanofarads>;
#[allow(non_upper_case_globals)]
pub static Nanofarads: UnitNanofaradsMul = UnitNanofaradsMul;
pub type Picofarads<T> = Quantity<T, UnitPicofarads>;
#[allow(non_upper_case_globals)]
pub static Picofarads: UnitPicofaradsMul = UnitPicofaradsMul;
pub type Femtofarads<T> = Quantity<T, UnitFemtofarads>;
#[allow(non_upper_case_globals)]
pub static Femtofarads: UnitFemtofaradsMul = UnitFemtofaradsMul;
pub type Attofarads<T> = Quantity<T, UnitAttofarads>;
#[allow(non_upper_case_globals)]
pub static Attofarads: UnitAttofaradsMul = UnitAttofaradsMul;
pub type Zeptofarads<T> = Quantity<T, UnitZeptofarads>;
#[allow(non_upper_case_globals)]
pub static Zeptofarads: UnitZeptofaradsMul = UnitZeptofaradsMul;
pub type Yoctofarads<T> = Quantity<T, UnitYoctofarads>;
#[allow(non_upper_case_globals)]
pub static Yoctofarads: UnitYoctofaradsMul = UnitYoctofaradsMul;
pub type Rontofarads<T> = Quantity<T, UnitRontofarads>;
#[allow(non_upper_case_globals)]
pub static Rontofarads: UnitRontofaradsMul = UnitRontofaradsMul;
pub type Quectofarads<T> = Quantity<T, UnitQuectofarads>;
#[allow(non_upper_case_globals)]
pub static Quectofarads: UnitQuectofaradsMul = UnitQuectofaradsMul;
pub struct UnitOhms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitOhms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitOhms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitOhms {
    #[inline]
    fn clone(&self) -> UnitOhms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitOhms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitOhms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitOhms {
    #[inline]
    fn eq(&self, other: &UnitOhms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitOhms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitOhms {
    fn default() -> Self {
        UnitOhms
    }
}
impl Add<UnitOhms> for UnitOhms {
    type Output = UnitOhms;
    #[inline]
    fn add(self, _: UnitOhms) -> Self::Output {
        UnitOhms
    }
}
impl AddAssign<UnitOhms> for UnitOhms {
    #[inline]
    fn add_assign(&mut self, _: UnitOhms) {}
}
impl Sub<UnitOhms> for UnitOhms {
    type Output = UnitOhms;
    #[inline]
    fn sub(self, _: UnitOhms) -> Self::Output {
        UnitOhms
    }
}
impl SubAssign<UnitOhms> for UnitOhms {
    #[inline]
    fn sub_assign(&mut self, _: UnitOhms) {}
}
pub struct UnitOhmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitOhmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitOhmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitOhmsMul {
    #[inline]
    fn clone(&self) -> UnitOhmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitOhmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitOhmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitOhmsMul {
    #[inline]
    fn eq(&self, other: &UnitOhmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitOhmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitOhmsMul> for i8 {
    type Output = Quantity<i8, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for i16 {
    type Output = Quantity<i16, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for i32 {
    type Output = Quantity<i32, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for i64 {
    type Output = Quantity<i64, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for i128 {
    type Output = Quantity<i128, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for isize {
    type Output = Quantity<isize, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for u8 {
    type Output = Quantity<u8, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for u16 {
    type Output = Quantity<u16, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for u32 {
    type Output = Quantity<u32, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for u64 {
    type Output = Quantity<u64, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for u128 {
    type Output = Quantity<u128, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for usize {
    type Output = Quantity<usize, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for f32 {
    type Output = Quantity<f32, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
impl Mul<UnitOhmsMul> for f64 {
    type Output = Quantity<f64, UnitOhms>;
    fn mul(self, _: UnitOhmsMul) -> Self::Output {
        Quantity::new(self, UnitOhms)
    }
}
pub struct UnitQuettaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaohms {
    #[inline]
    fn clone(&self) -> UnitQuettaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaohms {
    #[inline]
    fn eq(&self, other: &UnitQuettaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaohms {
    fn default() -> Self {
        UnitQuettaohms
    }
}
impl Add<UnitQuettaohms> for UnitQuettaohms {
    type Output = UnitQuettaohms;
    #[inline]
    fn add(self, _: UnitQuettaohms) -> Self::Output {
        UnitQuettaohms
    }
}
impl AddAssign<UnitQuettaohms> for UnitQuettaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaohms) {}
}
impl Sub<UnitQuettaohms> for UnitQuettaohms {
    type Output = UnitQuettaohms;
    #[inline]
    fn sub(self, _: UnitQuettaohms) -> Self::Output {
        UnitQuettaohms
    }
}
impl SubAssign<UnitQuettaohms> for UnitQuettaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaohms) {}
}
pub struct UnitQuettaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaohmsMul {
    #[inline]
    fn clone(&self) -> UnitQuettaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaohmsMul> for i8 {
    type Output = Quantity<i8, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for i16 {
    type Output = Quantity<i16, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for i32 {
    type Output = Quantity<i32, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for i64 {
    type Output = Quantity<i64, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for i128 {
    type Output = Quantity<i128, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for isize {
    type Output = Quantity<isize, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for u8 {
    type Output = Quantity<u8, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for u16 {
    type Output = Quantity<u16, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for u32 {
    type Output = Quantity<u32, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for u64 {
    type Output = Quantity<u64, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for u128 {
    type Output = Quantity<u128, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for usize {
    type Output = Quantity<usize, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for f32 {
    type Output = Quantity<f32, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
impl Mul<UnitQuettaohmsMul> for f64 {
    type Output = Quantity<f64, UnitQuettaohms>;
    fn mul(self, _: UnitQuettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaohms)
    }
}
pub struct UnitRonnaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaohms {
    #[inline]
    fn clone(&self) -> UnitRonnaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaohms {
    #[inline]
    fn eq(&self, other: &UnitRonnaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaohms {
    fn default() -> Self {
        UnitRonnaohms
    }
}
impl Add<UnitRonnaohms> for UnitRonnaohms {
    type Output = UnitRonnaohms;
    #[inline]
    fn add(self, _: UnitRonnaohms) -> Self::Output {
        UnitRonnaohms
    }
}
impl AddAssign<UnitRonnaohms> for UnitRonnaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaohms) {}
}
impl Sub<UnitRonnaohms> for UnitRonnaohms {
    type Output = UnitRonnaohms;
    #[inline]
    fn sub(self, _: UnitRonnaohms) -> Self::Output {
        UnitRonnaohms
    }
}
impl SubAssign<UnitRonnaohms> for UnitRonnaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaohms) {}
}
pub struct UnitRonnaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaohmsMul {
    #[inline]
    fn clone(&self) -> UnitRonnaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaohmsMul> for i8 {
    type Output = Quantity<i8, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for i16 {
    type Output = Quantity<i16, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for i32 {
    type Output = Quantity<i32, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for i64 {
    type Output = Quantity<i64, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for i128 {
    type Output = Quantity<i128, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for isize {
    type Output = Quantity<isize, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for u8 {
    type Output = Quantity<u8, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for u16 {
    type Output = Quantity<u16, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for u32 {
    type Output = Quantity<u32, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for u64 {
    type Output = Quantity<u64, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for u128 {
    type Output = Quantity<u128, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for usize {
    type Output = Quantity<usize, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for f32 {
    type Output = Quantity<f32, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
impl Mul<UnitRonnaohmsMul> for f64 {
    type Output = Quantity<f64, UnitRonnaohms>;
    fn mul(self, _: UnitRonnaohmsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaohms)
    }
}
pub struct UnitYottaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaohms {
    #[inline]
    fn clone(&self) -> UnitYottaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaohms {
    #[inline]
    fn eq(&self, other: &UnitYottaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaohms {
    fn default() -> Self {
        UnitYottaohms
    }
}
impl Add<UnitYottaohms> for UnitYottaohms {
    type Output = UnitYottaohms;
    #[inline]
    fn add(self, _: UnitYottaohms) -> Self::Output {
        UnitYottaohms
    }
}
impl AddAssign<UnitYottaohms> for UnitYottaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaohms) {}
}
impl Sub<UnitYottaohms> for UnitYottaohms {
    type Output = UnitYottaohms;
    #[inline]
    fn sub(self, _: UnitYottaohms) -> Self::Output {
        UnitYottaohms
    }
}
impl SubAssign<UnitYottaohms> for UnitYottaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaohms) {}
}
pub struct UnitYottaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaohmsMul {
    #[inline]
    fn clone(&self) -> UnitYottaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitYottaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaohmsMul> for i8 {
    type Output = Quantity<i8, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for i16 {
    type Output = Quantity<i16, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for i32 {
    type Output = Quantity<i32, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for i64 {
    type Output = Quantity<i64, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for i128 {
    type Output = Quantity<i128, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for isize {
    type Output = Quantity<isize, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for u8 {
    type Output = Quantity<u8, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for u16 {
    type Output = Quantity<u16, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for u32 {
    type Output = Quantity<u32, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for u64 {
    type Output = Quantity<u64, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for u128 {
    type Output = Quantity<u128, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for usize {
    type Output = Quantity<usize, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for f32 {
    type Output = Quantity<f32, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
impl Mul<UnitYottaohmsMul> for f64 {
    type Output = Quantity<f64, UnitYottaohms>;
    fn mul(self, _: UnitYottaohmsMul) -> Self::Output {
        Quantity::new(self, UnitYottaohms)
    }
}
pub struct UnitZettaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaohms {
    #[inline]
    fn clone(&self) -> UnitZettaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaohms {
    #[inline]
    fn eq(&self, other: &UnitZettaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaohms {
    fn default() -> Self {
        UnitZettaohms
    }
}
impl Add<UnitZettaohms> for UnitZettaohms {
    type Output = UnitZettaohms;
    #[inline]
    fn add(self, _: UnitZettaohms) -> Self::Output {
        UnitZettaohms
    }
}
impl AddAssign<UnitZettaohms> for UnitZettaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaohms) {}
}
impl Sub<UnitZettaohms> for UnitZettaohms {
    type Output = UnitZettaohms;
    #[inline]
    fn sub(self, _: UnitZettaohms) -> Self::Output {
        UnitZettaohms
    }
}
impl SubAssign<UnitZettaohms> for UnitZettaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaohms) {}
}
pub struct UnitZettaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaohmsMul {
    #[inline]
    fn clone(&self) -> UnitZettaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitZettaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaohmsMul> for i8 {
    type Output = Quantity<i8, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for i16 {
    type Output = Quantity<i16, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for i32 {
    type Output = Quantity<i32, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for i64 {
    type Output = Quantity<i64, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for i128 {
    type Output = Quantity<i128, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for isize {
    type Output = Quantity<isize, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for u8 {
    type Output = Quantity<u8, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for u16 {
    type Output = Quantity<u16, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for u32 {
    type Output = Quantity<u32, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for u64 {
    type Output = Quantity<u64, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for u128 {
    type Output = Quantity<u128, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for usize {
    type Output = Quantity<usize, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for f32 {
    type Output = Quantity<f32, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
impl Mul<UnitZettaohmsMul> for f64 {
    type Output = Quantity<f64, UnitZettaohms>;
    fn mul(self, _: UnitZettaohmsMul) -> Self::Output {
        Quantity::new(self, UnitZettaohms)
    }
}
pub struct UnitExaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaohms {
    #[inline]
    fn clone(&self) -> UnitExaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaohms {
    #[inline]
    fn eq(&self, other: &UnitExaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaohms {
    fn default() -> Self {
        UnitExaohms
    }
}
impl Add<UnitExaohms> for UnitExaohms {
    type Output = UnitExaohms;
    #[inline]
    fn add(self, _: UnitExaohms) -> Self::Output {
        UnitExaohms
    }
}
impl AddAssign<UnitExaohms> for UnitExaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitExaohms) {}
}
impl Sub<UnitExaohms> for UnitExaohms {
    type Output = UnitExaohms;
    #[inline]
    fn sub(self, _: UnitExaohms) -> Self::Output {
        UnitExaohms
    }
}
impl SubAssign<UnitExaohms> for UnitExaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaohms) {}
}
pub struct UnitExaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaohmsMul {
    #[inline]
    fn clone(&self) -> UnitExaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitExaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaohmsMul> for i8 {
    type Output = Quantity<i8, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for i16 {
    type Output = Quantity<i16, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for i32 {
    type Output = Quantity<i32, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for i64 {
    type Output = Quantity<i64, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for i128 {
    type Output = Quantity<i128, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for isize {
    type Output = Quantity<isize, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for u8 {
    type Output = Quantity<u8, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for u16 {
    type Output = Quantity<u16, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for u32 {
    type Output = Quantity<u32, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for u64 {
    type Output = Quantity<u64, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for u128 {
    type Output = Quantity<u128, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for usize {
    type Output = Quantity<usize, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for f32 {
    type Output = Quantity<f32, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
impl Mul<UnitExaohmsMul> for f64 {
    type Output = Quantity<f64, UnitExaohms>;
    fn mul(self, _: UnitExaohmsMul) -> Self::Output {
        Quantity::new(self, UnitExaohms)
    }
}
pub struct UnitPetaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaohms {
    #[inline]
    fn clone(&self) -> UnitPetaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaohms {
    #[inline]
    fn eq(&self, other: &UnitPetaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaohms {
    fn default() -> Self {
        UnitPetaohms
    }
}
impl Add<UnitPetaohms> for UnitPetaohms {
    type Output = UnitPetaohms;
    #[inline]
    fn add(self, _: UnitPetaohms) -> Self::Output {
        UnitPetaohms
    }
}
impl AddAssign<UnitPetaohms> for UnitPetaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaohms) {}
}
impl Sub<UnitPetaohms> for UnitPetaohms {
    type Output = UnitPetaohms;
    #[inline]
    fn sub(self, _: UnitPetaohms) -> Self::Output {
        UnitPetaohms
    }
}
impl SubAssign<UnitPetaohms> for UnitPetaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaohms) {}
}
pub struct UnitPetaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaohmsMul {
    #[inline]
    fn clone(&self) -> UnitPetaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitPetaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaohmsMul> for i8 {
    type Output = Quantity<i8, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for i16 {
    type Output = Quantity<i16, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for i32 {
    type Output = Quantity<i32, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for i64 {
    type Output = Quantity<i64, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for i128 {
    type Output = Quantity<i128, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for isize {
    type Output = Quantity<isize, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for u8 {
    type Output = Quantity<u8, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for u16 {
    type Output = Quantity<u16, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for u32 {
    type Output = Quantity<u32, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for u64 {
    type Output = Quantity<u64, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for u128 {
    type Output = Quantity<u128, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for usize {
    type Output = Quantity<usize, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for f32 {
    type Output = Quantity<f32, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
impl Mul<UnitPetaohmsMul> for f64 {
    type Output = Quantity<f64, UnitPetaohms>;
    fn mul(self, _: UnitPetaohmsMul) -> Self::Output {
        Quantity::new(self, UnitPetaohms)
    }
}
pub struct UnitTeraohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraohms {
    #[inline]
    fn clone(&self) -> UnitTeraohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraohms {
    #[inline]
    fn eq(&self, other: &UnitTeraohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraohms {
    fn default() -> Self {
        UnitTeraohms
    }
}
impl Add<UnitTeraohms> for UnitTeraohms {
    type Output = UnitTeraohms;
    #[inline]
    fn add(self, _: UnitTeraohms) -> Self::Output {
        UnitTeraohms
    }
}
impl AddAssign<UnitTeraohms> for UnitTeraohms {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraohms) {}
}
impl Sub<UnitTeraohms> for UnitTeraohms {
    type Output = UnitTeraohms;
    #[inline]
    fn sub(self, _: UnitTeraohms) -> Self::Output {
        UnitTeraohms
    }
}
impl SubAssign<UnitTeraohms> for UnitTeraohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraohms) {}
}
pub struct UnitTeraohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraohmsMul {
    #[inline]
    fn clone(&self) -> UnitTeraohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraohmsMul {
    #[inline]
    fn eq(&self, other: &UnitTeraohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraohmsMul> for i8 {
    type Output = Quantity<i8, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for i16 {
    type Output = Quantity<i16, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for i32 {
    type Output = Quantity<i32, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for i64 {
    type Output = Quantity<i64, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for i128 {
    type Output = Quantity<i128, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for isize {
    type Output = Quantity<isize, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for u8 {
    type Output = Quantity<u8, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for u16 {
    type Output = Quantity<u16, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for u32 {
    type Output = Quantity<u32, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for u64 {
    type Output = Quantity<u64, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for u128 {
    type Output = Quantity<u128, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for usize {
    type Output = Quantity<usize, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for f32 {
    type Output = Quantity<f32, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
impl Mul<UnitTeraohmsMul> for f64 {
    type Output = Quantity<f64, UnitTeraohms>;
    fn mul(self, _: UnitTeraohmsMul) -> Self::Output {
        Quantity::new(self, UnitTeraohms)
    }
}
pub struct UnitGigaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaohms {
    #[inline]
    fn clone(&self) -> UnitGigaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaohms {
    #[inline]
    fn eq(&self, other: &UnitGigaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaohms {
    fn default() -> Self {
        UnitGigaohms
    }
}
impl Add<UnitGigaohms> for UnitGigaohms {
    type Output = UnitGigaohms;
    #[inline]
    fn add(self, _: UnitGigaohms) -> Self::Output {
        UnitGigaohms
    }
}
impl AddAssign<UnitGigaohms> for UnitGigaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaohms) {}
}
impl Sub<UnitGigaohms> for UnitGigaohms {
    type Output = UnitGigaohms;
    #[inline]
    fn sub(self, _: UnitGigaohms) -> Self::Output {
        UnitGigaohms
    }
}
impl SubAssign<UnitGigaohms> for UnitGigaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaohms) {}
}
pub struct UnitGigaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaohmsMul {
    #[inline]
    fn clone(&self) -> UnitGigaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitGigaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaohmsMul> for i8 {
    type Output = Quantity<i8, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for i16 {
    type Output = Quantity<i16, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for i32 {
    type Output = Quantity<i32, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for i64 {
    type Output = Quantity<i64, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for i128 {
    type Output = Quantity<i128, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for isize {
    type Output = Quantity<isize, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for u8 {
    type Output = Quantity<u8, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for u16 {
    type Output = Quantity<u16, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for u32 {
    type Output = Quantity<u32, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for u64 {
    type Output = Quantity<u64, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for u128 {
    type Output = Quantity<u128, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for usize {
    type Output = Quantity<usize, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for f32 {
    type Output = Quantity<f32, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
impl Mul<UnitGigaohmsMul> for f64 {
    type Output = Quantity<f64, UnitGigaohms>;
    fn mul(self, _: UnitGigaohmsMul) -> Self::Output {
        Quantity::new(self, UnitGigaohms)
    }
}
pub struct UnitMegaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaohms {
    #[inline]
    fn clone(&self) -> UnitMegaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaohms {
    #[inline]
    fn eq(&self, other: &UnitMegaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaohms {
    fn default() -> Self {
        UnitMegaohms
    }
}
impl Add<UnitMegaohms> for UnitMegaohms {
    type Output = UnitMegaohms;
    #[inline]
    fn add(self, _: UnitMegaohms) -> Self::Output {
        UnitMegaohms
    }
}
impl AddAssign<UnitMegaohms> for UnitMegaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaohms) {}
}
impl Sub<UnitMegaohms> for UnitMegaohms {
    type Output = UnitMegaohms;
    #[inline]
    fn sub(self, _: UnitMegaohms) -> Self::Output {
        UnitMegaohms
    }
}
impl SubAssign<UnitMegaohms> for UnitMegaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaohms) {}
}
pub struct UnitMegaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaohmsMul {
    #[inline]
    fn clone(&self) -> UnitMegaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitMegaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaohmsMul> for i8 {
    type Output = Quantity<i8, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for i16 {
    type Output = Quantity<i16, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for i32 {
    type Output = Quantity<i32, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for i64 {
    type Output = Quantity<i64, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for i128 {
    type Output = Quantity<i128, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for isize {
    type Output = Quantity<isize, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for u8 {
    type Output = Quantity<u8, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for u16 {
    type Output = Quantity<u16, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for u32 {
    type Output = Quantity<u32, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for u64 {
    type Output = Quantity<u64, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for u128 {
    type Output = Quantity<u128, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for usize {
    type Output = Quantity<usize, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for f32 {
    type Output = Quantity<f32, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
impl Mul<UnitMegaohmsMul> for f64 {
    type Output = Quantity<f64, UnitMegaohms>;
    fn mul(self, _: UnitMegaohmsMul) -> Self::Output {
        Quantity::new(self, UnitMegaohms)
    }
}
pub struct UnitKiloohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloohms {
    #[inline]
    fn clone(&self) -> UnitKiloohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloohms {
    #[inline]
    fn eq(&self, other: &UnitKiloohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloohms {
    fn default() -> Self {
        UnitKiloohms
    }
}
impl Add<UnitKiloohms> for UnitKiloohms {
    type Output = UnitKiloohms;
    #[inline]
    fn add(self, _: UnitKiloohms) -> Self::Output {
        UnitKiloohms
    }
}
impl AddAssign<UnitKiloohms> for UnitKiloohms {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloohms) {}
}
impl Sub<UnitKiloohms> for UnitKiloohms {
    type Output = UnitKiloohms;
    #[inline]
    fn sub(self, _: UnitKiloohms) -> Self::Output {
        UnitKiloohms
    }
}
impl SubAssign<UnitKiloohms> for UnitKiloohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloohms) {}
}
pub struct UnitKiloohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloohmsMul {
    #[inline]
    fn clone(&self) -> UnitKiloohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloohmsMul {
    #[inline]
    fn eq(&self, other: &UnitKiloohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloohmsMul> for i8 {
    type Output = Quantity<i8, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for i16 {
    type Output = Quantity<i16, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for i32 {
    type Output = Quantity<i32, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for i64 {
    type Output = Quantity<i64, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for i128 {
    type Output = Quantity<i128, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for isize {
    type Output = Quantity<isize, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for u8 {
    type Output = Quantity<u8, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for u16 {
    type Output = Quantity<u16, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for u32 {
    type Output = Quantity<u32, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for u64 {
    type Output = Quantity<u64, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for u128 {
    type Output = Quantity<u128, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for usize {
    type Output = Quantity<usize, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for f32 {
    type Output = Quantity<f32, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
impl Mul<UnitKiloohmsMul> for f64 {
    type Output = Quantity<f64, UnitKiloohms>;
    fn mul(self, _: UnitKiloohmsMul) -> Self::Output {
        Quantity::new(self, UnitKiloohms)
    }
}
pub struct UnitHectoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoohms {
    #[inline]
    fn clone(&self) -> UnitHectoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoohms {
    #[inline]
    fn eq(&self, other: &UnitHectoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoohms {
    fn default() -> Self {
        UnitHectoohms
    }
}
impl Add<UnitHectoohms> for UnitHectoohms {
    type Output = UnitHectoohms;
    #[inline]
    fn add(self, _: UnitHectoohms) -> Self::Output {
        UnitHectoohms
    }
}
impl AddAssign<UnitHectoohms> for UnitHectoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoohms) {}
}
impl Sub<UnitHectoohms> for UnitHectoohms {
    type Output = UnitHectoohms;
    #[inline]
    fn sub(self, _: UnitHectoohms) -> Self::Output {
        UnitHectoohms
    }
}
impl SubAssign<UnitHectoohms> for UnitHectoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoohms) {}
}
pub struct UnitHectoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoohmsMul {
    #[inline]
    fn clone(&self) -> UnitHectoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitHectoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoohmsMul> for i8 {
    type Output = Quantity<i8, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for i16 {
    type Output = Quantity<i16, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for i32 {
    type Output = Quantity<i32, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for i64 {
    type Output = Quantity<i64, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for i128 {
    type Output = Quantity<i128, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for isize {
    type Output = Quantity<isize, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for u8 {
    type Output = Quantity<u8, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for u16 {
    type Output = Quantity<u16, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for u32 {
    type Output = Quantity<u32, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for u64 {
    type Output = Quantity<u64, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for u128 {
    type Output = Quantity<u128, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for usize {
    type Output = Quantity<usize, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for f32 {
    type Output = Quantity<f32, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
impl Mul<UnitHectoohmsMul> for f64 {
    type Output = Quantity<f64, UnitHectoohms>;
    fn mul(self, _: UnitHectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitHectoohms)
    }
}
pub struct UnitDecaohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaohms {
    #[inline]
    fn clone(&self) -> UnitDecaohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaohms {
    #[inline]
    fn eq(&self, other: &UnitDecaohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaohms {
    fn default() -> Self {
        UnitDecaohms
    }
}
impl Add<UnitDecaohms> for UnitDecaohms {
    type Output = UnitDecaohms;
    #[inline]
    fn add(self, _: UnitDecaohms) -> Self::Output {
        UnitDecaohms
    }
}
impl AddAssign<UnitDecaohms> for UnitDecaohms {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaohms) {}
}
impl Sub<UnitDecaohms> for UnitDecaohms {
    type Output = UnitDecaohms;
    #[inline]
    fn sub(self, _: UnitDecaohms) -> Self::Output {
        UnitDecaohms
    }
}
impl SubAssign<UnitDecaohms> for UnitDecaohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaohms) {}
}
pub struct UnitDecaohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaohmsMul {
    #[inline]
    fn clone(&self) -> UnitDecaohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaohmsMul {
    #[inline]
    fn eq(&self, other: &UnitDecaohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaohmsMul> for i8 {
    type Output = Quantity<i8, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for i16 {
    type Output = Quantity<i16, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for i32 {
    type Output = Quantity<i32, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for i64 {
    type Output = Quantity<i64, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for i128 {
    type Output = Quantity<i128, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for isize {
    type Output = Quantity<isize, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for u8 {
    type Output = Quantity<u8, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for u16 {
    type Output = Quantity<u16, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for u32 {
    type Output = Quantity<u32, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for u64 {
    type Output = Quantity<u64, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for u128 {
    type Output = Quantity<u128, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for usize {
    type Output = Quantity<usize, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for f32 {
    type Output = Quantity<f32, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
impl Mul<UnitDecaohmsMul> for f64 {
    type Output = Quantity<f64, UnitDecaohms>;
    fn mul(self, _: UnitDecaohmsMul) -> Self::Output {
        Quantity::new(self, UnitDecaohms)
    }
}
pub struct UnitDeciohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciohms {
    #[inline]
    fn clone(&self) -> UnitDeciohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciohms {
    #[inline]
    fn eq(&self, other: &UnitDeciohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciohms {
    fn default() -> Self {
        UnitDeciohms
    }
}
impl Add<UnitDeciohms> for UnitDeciohms {
    type Output = UnitDeciohms;
    #[inline]
    fn add(self, _: UnitDeciohms) -> Self::Output {
        UnitDeciohms
    }
}
impl AddAssign<UnitDeciohms> for UnitDeciohms {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciohms) {}
}
impl Sub<UnitDeciohms> for UnitDeciohms {
    type Output = UnitDeciohms;
    #[inline]
    fn sub(self, _: UnitDeciohms) -> Self::Output {
        UnitDeciohms
    }
}
impl SubAssign<UnitDeciohms> for UnitDeciohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciohms) {}
}
pub struct UnitDeciohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciohmsMul {
    #[inline]
    fn clone(&self) -> UnitDeciohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciohmsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciohmsMul> for i8 {
    type Output = Quantity<i8, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for i16 {
    type Output = Quantity<i16, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for i32 {
    type Output = Quantity<i32, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for i64 {
    type Output = Quantity<i64, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for i128 {
    type Output = Quantity<i128, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for isize {
    type Output = Quantity<isize, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for u8 {
    type Output = Quantity<u8, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for u16 {
    type Output = Quantity<u16, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for u32 {
    type Output = Quantity<u32, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for u64 {
    type Output = Quantity<u64, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for u128 {
    type Output = Quantity<u128, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for usize {
    type Output = Quantity<usize, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for f32 {
    type Output = Quantity<f32, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
impl Mul<UnitDeciohmsMul> for f64 {
    type Output = Quantity<f64, UnitDeciohms>;
    fn mul(self, _: UnitDeciohmsMul) -> Self::Output {
        Quantity::new(self, UnitDeciohms)
    }
}
pub struct UnitCentiohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiohms {
    #[inline]
    fn clone(&self) -> UnitCentiohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiohms {
    #[inline]
    fn eq(&self, other: &UnitCentiohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiohms {
    fn default() -> Self {
        UnitCentiohms
    }
}
impl Add<UnitCentiohms> for UnitCentiohms {
    type Output = UnitCentiohms;
    #[inline]
    fn add(self, _: UnitCentiohms) -> Self::Output {
        UnitCentiohms
    }
}
impl AddAssign<UnitCentiohms> for UnitCentiohms {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiohms) {}
}
impl Sub<UnitCentiohms> for UnitCentiohms {
    type Output = UnitCentiohms;
    #[inline]
    fn sub(self, _: UnitCentiohms) -> Self::Output {
        UnitCentiohms
    }
}
impl SubAssign<UnitCentiohms> for UnitCentiohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiohms) {}
}
pub struct UnitCentiohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiohmsMul {
    #[inline]
    fn clone(&self) -> UnitCentiohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiohmsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiohmsMul> for i8 {
    type Output = Quantity<i8, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for i16 {
    type Output = Quantity<i16, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for i32 {
    type Output = Quantity<i32, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for i64 {
    type Output = Quantity<i64, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for i128 {
    type Output = Quantity<i128, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for isize {
    type Output = Quantity<isize, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for u8 {
    type Output = Quantity<u8, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for u16 {
    type Output = Quantity<u16, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for u32 {
    type Output = Quantity<u32, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for u64 {
    type Output = Quantity<u64, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for u128 {
    type Output = Quantity<u128, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for usize {
    type Output = Quantity<usize, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for f32 {
    type Output = Quantity<f32, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
impl Mul<UnitCentiohmsMul> for f64 {
    type Output = Quantity<f64, UnitCentiohms>;
    fn mul(self, _: UnitCentiohmsMul) -> Self::Output {
        Quantity::new(self, UnitCentiohms)
    }
}
pub struct UnitMilliohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliohms {
    #[inline]
    fn clone(&self) -> UnitMilliohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliohms {
    #[inline]
    fn eq(&self, other: &UnitMilliohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliohms {
    fn default() -> Self {
        UnitMilliohms
    }
}
impl Add<UnitMilliohms> for UnitMilliohms {
    type Output = UnitMilliohms;
    #[inline]
    fn add(self, _: UnitMilliohms) -> Self::Output {
        UnitMilliohms
    }
}
impl AddAssign<UnitMilliohms> for UnitMilliohms {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliohms) {}
}
impl Sub<UnitMilliohms> for UnitMilliohms {
    type Output = UnitMilliohms;
    #[inline]
    fn sub(self, _: UnitMilliohms) -> Self::Output {
        UnitMilliohms
    }
}
impl SubAssign<UnitMilliohms> for UnitMilliohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliohms) {}
}
pub struct UnitMilliohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliohmsMul {
    #[inline]
    fn clone(&self) -> UnitMilliohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliohmsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliohmsMul> for i8 {
    type Output = Quantity<i8, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for i16 {
    type Output = Quantity<i16, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for i32 {
    type Output = Quantity<i32, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for i64 {
    type Output = Quantity<i64, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for i128 {
    type Output = Quantity<i128, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for isize {
    type Output = Quantity<isize, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for u8 {
    type Output = Quantity<u8, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for u16 {
    type Output = Quantity<u16, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for u32 {
    type Output = Quantity<u32, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for u64 {
    type Output = Quantity<u64, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for u128 {
    type Output = Quantity<u128, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for usize {
    type Output = Quantity<usize, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for f32 {
    type Output = Quantity<f32, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
impl Mul<UnitMilliohmsMul> for f64 {
    type Output = Quantity<f64, UnitMilliohms>;
    fn mul(self, _: UnitMilliohmsMul) -> Self::Output {
        Quantity::new(self, UnitMilliohms)
    }
}
pub struct UnitMicroohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroohms {
    #[inline]
    fn clone(&self) -> UnitMicroohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroohms {
    #[inline]
    fn eq(&self, other: &UnitMicroohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroohms {
    fn default() -> Self {
        UnitMicroohms
    }
}
impl Add<UnitMicroohms> for UnitMicroohms {
    type Output = UnitMicroohms;
    #[inline]
    fn add(self, _: UnitMicroohms) -> Self::Output {
        UnitMicroohms
    }
}
impl AddAssign<UnitMicroohms> for UnitMicroohms {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroohms) {}
}
impl Sub<UnitMicroohms> for UnitMicroohms {
    type Output = UnitMicroohms;
    #[inline]
    fn sub(self, _: UnitMicroohms) -> Self::Output {
        UnitMicroohms
    }
}
impl SubAssign<UnitMicroohms> for UnitMicroohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroohms) {}
}
pub struct UnitMicroohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroohmsMul {
    #[inline]
    fn clone(&self) -> UnitMicroohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroohmsMul {
    #[inline]
    fn eq(&self, other: &UnitMicroohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroohmsMul> for i8 {
    type Output = Quantity<i8, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for i16 {
    type Output = Quantity<i16, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for i32 {
    type Output = Quantity<i32, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for i64 {
    type Output = Quantity<i64, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for i128 {
    type Output = Quantity<i128, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for isize {
    type Output = Quantity<isize, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for u8 {
    type Output = Quantity<u8, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for u16 {
    type Output = Quantity<u16, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for u32 {
    type Output = Quantity<u32, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for u64 {
    type Output = Quantity<u64, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for u128 {
    type Output = Quantity<u128, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for usize {
    type Output = Quantity<usize, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for f32 {
    type Output = Quantity<f32, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
impl Mul<UnitMicroohmsMul> for f64 {
    type Output = Quantity<f64, UnitMicroohms>;
    fn mul(self, _: UnitMicroohmsMul) -> Self::Output {
        Quantity::new(self, UnitMicroohms)
    }
}
pub struct UnitNanoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoohms {
    #[inline]
    fn clone(&self) -> UnitNanoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoohms {
    #[inline]
    fn eq(&self, other: &UnitNanoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoohms {
    fn default() -> Self {
        UnitNanoohms
    }
}
impl Add<UnitNanoohms> for UnitNanoohms {
    type Output = UnitNanoohms;
    #[inline]
    fn add(self, _: UnitNanoohms) -> Self::Output {
        UnitNanoohms
    }
}
impl AddAssign<UnitNanoohms> for UnitNanoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoohms) {}
}
impl Sub<UnitNanoohms> for UnitNanoohms {
    type Output = UnitNanoohms;
    #[inline]
    fn sub(self, _: UnitNanoohms) -> Self::Output {
        UnitNanoohms
    }
}
impl SubAssign<UnitNanoohms> for UnitNanoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoohms) {}
}
pub struct UnitNanoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoohmsMul {
    #[inline]
    fn clone(&self) -> UnitNanoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitNanoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoohmsMul> for i8 {
    type Output = Quantity<i8, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for i16 {
    type Output = Quantity<i16, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for i32 {
    type Output = Quantity<i32, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for i64 {
    type Output = Quantity<i64, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for i128 {
    type Output = Quantity<i128, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for isize {
    type Output = Quantity<isize, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for u8 {
    type Output = Quantity<u8, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for u16 {
    type Output = Quantity<u16, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for u32 {
    type Output = Quantity<u32, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for u64 {
    type Output = Quantity<u64, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for u128 {
    type Output = Quantity<u128, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for usize {
    type Output = Quantity<usize, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for f32 {
    type Output = Quantity<f32, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
impl Mul<UnitNanoohmsMul> for f64 {
    type Output = Quantity<f64, UnitNanoohms>;
    fn mul(self, _: UnitNanoohmsMul) -> Self::Output {
        Quantity::new(self, UnitNanoohms)
    }
}
pub struct UnitPicoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoohms {
    #[inline]
    fn clone(&self) -> UnitPicoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoohms {
    #[inline]
    fn eq(&self, other: &UnitPicoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoohms {
    fn default() -> Self {
        UnitPicoohms
    }
}
impl Add<UnitPicoohms> for UnitPicoohms {
    type Output = UnitPicoohms;
    #[inline]
    fn add(self, _: UnitPicoohms) -> Self::Output {
        UnitPicoohms
    }
}
impl AddAssign<UnitPicoohms> for UnitPicoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoohms) {}
}
impl Sub<UnitPicoohms> for UnitPicoohms {
    type Output = UnitPicoohms;
    #[inline]
    fn sub(self, _: UnitPicoohms) -> Self::Output {
        UnitPicoohms
    }
}
impl SubAssign<UnitPicoohms> for UnitPicoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoohms) {}
}
pub struct UnitPicoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoohmsMul {
    #[inline]
    fn clone(&self) -> UnitPicoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitPicoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoohmsMul> for i8 {
    type Output = Quantity<i8, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for i16 {
    type Output = Quantity<i16, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for i32 {
    type Output = Quantity<i32, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for i64 {
    type Output = Quantity<i64, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for i128 {
    type Output = Quantity<i128, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for isize {
    type Output = Quantity<isize, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for u8 {
    type Output = Quantity<u8, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for u16 {
    type Output = Quantity<u16, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for u32 {
    type Output = Quantity<u32, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for u64 {
    type Output = Quantity<u64, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for u128 {
    type Output = Quantity<u128, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for usize {
    type Output = Quantity<usize, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for f32 {
    type Output = Quantity<f32, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
impl Mul<UnitPicoohmsMul> for f64 {
    type Output = Quantity<f64, UnitPicoohms>;
    fn mul(self, _: UnitPicoohmsMul) -> Self::Output {
        Quantity::new(self, UnitPicoohms)
    }
}
pub struct UnitFemtoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoohms {
    #[inline]
    fn clone(&self) -> UnitFemtoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoohms {
    #[inline]
    fn eq(&self, other: &UnitFemtoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoohms {
    fn default() -> Self {
        UnitFemtoohms
    }
}
impl Add<UnitFemtoohms> for UnitFemtoohms {
    type Output = UnitFemtoohms;
    #[inline]
    fn add(self, _: UnitFemtoohms) -> Self::Output {
        UnitFemtoohms
    }
}
impl AddAssign<UnitFemtoohms> for UnitFemtoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoohms) {}
}
impl Sub<UnitFemtoohms> for UnitFemtoohms {
    type Output = UnitFemtoohms;
    #[inline]
    fn sub(self, _: UnitFemtoohms) -> Self::Output {
        UnitFemtoohms
    }
}
impl SubAssign<UnitFemtoohms> for UnitFemtoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoohms) {}
}
pub struct UnitFemtoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoohmsMul {
    #[inline]
    fn clone(&self) -> UnitFemtoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoohmsMul> for i8 {
    type Output = Quantity<i8, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for i16 {
    type Output = Quantity<i16, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for i32 {
    type Output = Quantity<i32, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for i64 {
    type Output = Quantity<i64, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for i128 {
    type Output = Quantity<i128, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for isize {
    type Output = Quantity<isize, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for u8 {
    type Output = Quantity<u8, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for u16 {
    type Output = Quantity<u16, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for u32 {
    type Output = Quantity<u32, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for u64 {
    type Output = Quantity<u64, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for u128 {
    type Output = Quantity<u128, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for usize {
    type Output = Quantity<usize, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for f32 {
    type Output = Quantity<f32, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
impl Mul<UnitFemtoohmsMul> for f64 {
    type Output = Quantity<f64, UnitFemtoohms>;
    fn mul(self, _: UnitFemtoohmsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoohms)
    }
}
pub struct UnitAttoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoohms {
    #[inline]
    fn clone(&self) -> UnitAttoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoohms {
    #[inline]
    fn eq(&self, other: &UnitAttoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoohms {
    fn default() -> Self {
        UnitAttoohms
    }
}
impl Add<UnitAttoohms> for UnitAttoohms {
    type Output = UnitAttoohms;
    #[inline]
    fn add(self, _: UnitAttoohms) -> Self::Output {
        UnitAttoohms
    }
}
impl AddAssign<UnitAttoohms> for UnitAttoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoohms) {}
}
impl Sub<UnitAttoohms> for UnitAttoohms {
    type Output = UnitAttoohms;
    #[inline]
    fn sub(self, _: UnitAttoohms) -> Self::Output {
        UnitAttoohms
    }
}
impl SubAssign<UnitAttoohms> for UnitAttoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoohms) {}
}
pub struct UnitAttoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoohmsMul {
    #[inline]
    fn clone(&self) -> UnitAttoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitAttoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoohmsMul> for i8 {
    type Output = Quantity<i8, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for i16 {
    type Output = Quantity<i16, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for i32 {
    type Output = Quantity<i32, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for i64 {
    type Output = Quantity<i64, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for i128 {
    type Output = Quantity<i128, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for isize {
    type Output = Quantity<isize, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for u8 {
    type Output = Quantity<u8, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for u16 {
    type Output = Quantity<u16, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for u32 {
    type Output = Quantity<u32, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for u64 {
    type Output = Quantity<u64, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for u128 {
    type Output = Quantity<u128, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for usize {
    type Output = Quantity<usize, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for f32 {
    type Output = Quantity<f32, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
impl Mul<UnitAttoohmsMul> for f64 {
    type Output = Quantity<f64, UnitAttoohms>;
    fn mul(self, _: UnitAttoohmsMul) -> Self::Output {
        Quantity::new(self, UnitAttoohms)
    }
}
pub struct UnitZeptoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoohms {
    #[inline]
    fn clone(&self) -> UnitZeptoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoohms {
    #[inline]
    fn eq(&self, other: &UnitZeptoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoohms {
    fn default() -> Self {
        UnitZeptoohms
    }
}
impl Add<UnitZeptoohms> for UnitZeptoohms {
    type Output = UnitZeptoohms;
    #[inline]
    fn add(self, _: UnitZeptoohms) -> Self::Output {
        UnitZeptoohms
    }
}
impl AddAssign<UnitZeptoohms> for UnitZeptoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoohms) {}
}
impl Sub<UnitZeptoohms> for UnitZeptoohms {
    type Output = UnitZeptoohms;
    #[inline]
    fn sub(self, _: UnitZeptoohms) -> Self::Output {
        UnitZeptoohms
    }
}
impl SubAssign<UnitZeptoohms> for UnitZeptoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoohms) {}
}
pub struct UnitZeptoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoohmsMul {
    #[inline]
    fn clone(&self) -> UnitZeptoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoohmsMul> for i8 {
    type Output = Quantity<i8, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for i16 {
    type Output = Quantity<i16, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for i32 {
    type Output = Quantity<i32, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for i64 {
    type Output = Quantity<i64, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for i128 {
    type Output = Quantity<i128, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for isize {
    type Output = Quantity<isize, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for u8 {
    type Output = Quantity<u8, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for u16 {
    type Output = Quantity<u16, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for u32 {
    type Output = Quantity<u32, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for u64 {
    type Output = Quantity<u64, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for u128 {
    type Output = Quantity<u128, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for usize {
    type Output = Quantity<usize, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for f32 {
    type Output = Quantity<f32, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
impl Mul<UnitZeptoohmsMul> for f64 {
    type Output = Quantity<f64, UnitZeptoohms>;
    fn mul(self, _: UnitZeptoohmsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoohms)
    }
}
pub struct UnitYoctoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoohms {
    #[inline]
    fn clone(&self) -> UnitYoctoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoohms {
    #[inline]
    fn eq(&self, other: &UnitYoctoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoohms {
    fn default() -> Self {
        UnitYoctoohms
    }
}
impl Add<UnitYoctoohms> for UnitYoctoohms {
    type Output = UnitYoctoohms;
    #[inline]
    fn add(self, _: UnitYoctoohms) -> Self::Output {
        UnitYoctoohms
    }
}
impl AddAssign<UnitYoctoohms> for UnitYoctoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoohms) {}
}
impl Sub<UnitYoctoohms> for UnitYoctoohms {
    type Output = UnitYoctoohms;
    #[inline]
    fn sub(self, _: UnitYoctoohms) -> Self::Output {
        UnitYoctoohms
    }
}
impl SubAssign<UnitYoctoohms> for UnitYoctoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoohms) {}
}
pub struct UnitYoctoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoohmsMul {
    #[inline]
    fn clone(&self) -> UnitYoctoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoohmsMul> for i8 {
    type Output = Quantity<i8, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for i16 {
    type Output = Quantity<i16, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for i32 {
    type Output = Quantity<i32, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for i64 {
    type Output = Quantity<i64, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for i128 {
    type Output = Quantity<i128, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for isize {
    type Output = Quantity<isize, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for u8 {
    type Output = Quantity<u8, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for u16 {
    type Output = Quantity<u16, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for u32 {
    type Output = Quantity<u32, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for u64 {
    type Output = Quantity<u64, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for u128 {
    type Output = Quantity<u128, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for usize {
    type Output = Quantity<usize, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for f32 {
    type Output = Quantity<f32, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
impl Mul<UnitYoctoohmsMul> for f64 {
    type Output = Quantity<f64, UnitYoctoohms>;
    fn mul(self, _: UnitYoctoohmsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoohms)
    }
}
pub struct UnitRontoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoohms {
    #[inline]
    fn clone(&self) -> UnitRontoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoohms {
    #[inline]
    fn eq(&self, other: &UnitRontoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoohms {
    fn default() -> Self {
        UnitRontoohms
    }
}
impl Add<UnitRontoohms> for UnitRontoohms {
    type Output = UnitRontoohms;
    #[inline]
    fn add(self, _: UnitRontoohms) -> Self::Output {
        UnitRontoohms
    }
}
impl AddAssign<UnitRontoohms> for UnitRontoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoohms) {}
}
impl Sub<UnitRontoohms> for UnitRontoohms {
    type Output = UnitRontoohms;
    #[inline]
    fn sub(self, _: UnitRontoohms) -> Self::Output {
        UnitRontoohms
    }
}
impl SubAssign<UnitRontoohms> for UnitRontoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoohms) {}
}
pub struct UnitRontoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoohmsMul {
    #[inline]
    fn clone(&self) -> UnitRontoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitRontoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoohmsMul> for i8 {
    type Output = Quantity<i8, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for i16 {
    type Output = Quantity<i16, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for i32 {
    type Output = Quantity<i32, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for i64 {
    type Output = Quantity<i64, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for i128 {
    type Output = Quantity<i128, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for isize {
    type Output = Quantity<isize, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for u8 {
    type Output = Quantity<u8, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for u16 {
    type Output = Quantity<u16, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for u32 {
    type Output = Quantity<u32, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for u64 {
    type Output = Quantity<u64, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for u128 {
    type Output = Quantity<u128, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for usize {
    type Output = Quantity<usize, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for f32 {
    type Output = Quantity<f32, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
impl Mul<UnitRontoohmsMul> for f64 {
    type Output = Quantity<f64, UnitRontoohms>;
    fn mul(self, _: UnitRontoohmsMul) -> Self::Output {
        Quantity::new(self, UnitRontoohms)
    }
}
pub struct UnitQuectoohms;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoohms {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoohms")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoohms {
    #[inline]
    fn clone(&self) -> UnitQuectoohms {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoohms {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoohms {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoohms {
    #[inline]
    fn eq(&self, other: &UnitQuectoohms) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoohms {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoohms {
    fn default() -> Self {
        UnitQuectoohms
    }
}
impl Add<UnitQuectoohms> for UnitQuectoohms {
    type Output = UnitQuectoohms;
    #[inline]
    fn add(self, _: UnitQuectoohms) -> Self::Output {
        UnitQuectoohms
    }
}
impl AddAssign<UnitQuectoohms> for UnitQuectoohms {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoohms) {}
}
impl Sub<UnitQuectoohms> for UnitQuectoohms {
    type Output = UnitQuectoohms;
    #[inline]
    fn sub(self, _: UnitQuectoohms) -> Self::Output {
        UnitQuectoohms
    }
}
impl SubAssign<UnitQuectoohms> for UnitQuectoohms {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoohms) {}
}
pub struct UnitQuectoohmsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoohmsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoohmsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoohmsMul {
    #[inline]
    fn clone(&self) -> UnitQuectoohmsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoohmsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoohmsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoohmsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoohmsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoohmsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoohmsMul> for i8 {
    type Output = Quantity<i8, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for i16 {
    type Output = Quantity<i16, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for i32 {
    type Output = Quantity<i32, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for i64 {
    type Output = Quantity<i64, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for i128 {
    type Output = Quantity<i128, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for isize {
    type Output = Quantity<isize, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for u8 {
    type Output = Quantity<u8, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for u16 {
    type Output = Quantity<u16, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for u32 {
    type Output = Quantity<u32, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for u64 {
    type Output = Quantity<u64, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for u128 {
    type Output = Quantity<u128, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for usize {
    type Output = Quantity<usize, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for f32 {
    type Output = Quantity<f32, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
impl Mul<UnitQuectoohmsMul> for f64 {
    type Output = Quantity<f64, UnitQuectoohms>;
    fn mul(self, _: UnitQuectoohmsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoohms)
    }
}
pub type Ohms<T> = Quantity<T, UnitOhms>;
#[allow(non_upper_case_globals)]
pub static Ohms: UnitOhmsMul = UnitOhmsMul;
pub type Quettaohms<T> = Quantity<T, UnitQuettaohms>;
#[allow(non_upper_case_globals)]
pub static Quettaohms: UnitQuettaohmsMul = UnitQuettaohmsMul;
pub type Ronnaohms<T> = Quantity<T, UnitRonnaohms>;
#[allow(non_upper_case_globals)]
pub static Ronnaohms: UnitRonnaohmsMul = UnitRonnaohmsMul;
pub type Yottaohms<T> = Quantity<T, UnitYottaohms>;
#[allow(non_upper_case_globals)]
pub static Yottaohms: UnitYottaohmsMul = UnitYottaohmsMul;
pub type Zettaohms<T> = Quantity<T, UnitZettaohms>;
#[allow(non_upper_case_globals)]
pub static Zettaohms: UnitZettaohmsMul = UnitZettaohmsMul;
pub type Exaohms<T> = Quantity<T, UnitExaohms>;
#[allow(non_upper_case_globals)]
pub static Exaohms: UnitExaohmsMul = UnitExaohmsMul;
pub type Petaohms<T> = Quantity<T, UnitPetaohms>;
#[allow(non_upper_case_globals)]
pub static Petaohms: UnitPetaohmsMul = UnitPetaohmsMul;
pub type Teraohms<T> = Quantity<T, UnitTeraohms>;
#[allow(non_upper_case_globals)]
pub static Teraohms: UnitTeraohmsMul = UnitTeraohmsMul;
pub type Gigaohms<T> = Quantity<T, UnitGigaohms>;
#[allow(non_upper_case_globals)]
pub static Gigaohms: UnitGigaohmsMul = UnitGigaohmsMul;
pub type Megaohms<T> = Quantity<T, UnitMegaohms>;
#[allow(non_upper_case_globals)]
pub static Megaohms: UnitMegaohmsMul = UnitMegaohmsMul;
pub type Kiloohms<T> = Quantity<T, UnitKiloohms>;
#[allow(non_upper_case_globals)]
pub static Kiloohms: UnitKiloohmsMul = UnitKiloohmsMul;
pub type Hectoohms<T> = Quantity<T, UnitHectoohms>;
#[allow(non_upper_case_globals)]
pub static Hectoohms: UnitHectoohmsMul = UnitHectoohmsMul;
pub type Decaohms<T> = Quantity<T, UnitDecaohms>;
#[allow(non_upper_case_globals)]
pub static Decaohms: UnitDecaohmsMul = UnitDecaohmsMul;
pub type Deciohms<T> = Quantity<T, UnitDeciohms>;
#[allow(non_upper_case_globals)]
pub static Deciohms: UnitDeciohmsMul = UnitDeciohmsMul;
pub type Centiohms<T> = Quantity<T, UnitCentiohms>;
#[allow(non_upper_case_globals)]
pub static Centiohms: UnitCentiohmsMul = UnitCentiohmsMul;
pub type Milliohms<T> = Quantity<T, UnitMilliohms>;
#[allow(non_upper_case_globals)]
pub static Milliohms: UnitMilliohmsMul = UnitMilliohmsMul;
pub type Microohms<T> = Quantity<T, UnitMicroohms>;
#[allow(non_upper_case_globals)]
pub static Microohms: UnitMicroohmsMul = UnitMicroohmsMul;
pub type Nanoohms<T> = Quantity<T, UnitNanoohms>;
#[allow(non_upper_case_globals)]
pub static Nanoohms: UnitNanoohmsMul = UnitNanoohmsMul;
pub type Picoohms<T> = Quantity<T, UnitPicoohms>;
#[allow(non_upper_case_globals)]
pub static Picoohms: UnitPicoohmsMul = UnitPicoohmsMul;
pub type Femtoohms<T> = Quantity<T, UnitFemtoohms>;
#[allow(non_upper_case_globals)]
pub static Femtoohms: UnitFemtoohmsMul = UnitFemtoohmsMul;
pub type Attoohms<T> = Quantity<T, UnitAttoohms>;
#[allow(non_upper_case_globals)]
pub static Attoohms: UnitAttoohmsMul = UnitAttoohmsMul;
pub type Zeptoohms<T> = Quantity<T, UnitZeptoohms>;
#[allow(non_upper_case_globals)]
pub static Zeptoohms: UnitZeptoohmsMul = UnitZeptoohmsMul;
pub type Yoctoohms<T> = Quantity<T, UnitYoctoohms>;
#[allow(non_upper_case_globals)]
pub static Yoctoohms: UnitYoctoohmsMul = UnitYoctoohmsMul;
pub type Rontoohms<T> = Quantity<T, UnitRontoohms>;
#[allow(non_upper_case_globals)]
pub static Rontoohms: UnitRontoohmsMul = UnitRontoohmsMul;
pub type Quectoohms<T> = Quantity<T, UnitQuectoohms>;
#[allow(non_upper_case_globals)]
pub static Quectoohms: UnitQuectoohmsMul = UnitQuectoohmsMul;
pub struct UnitSiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSiemens {
    #[inline]
    fn clone(&self) -> UnitSiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSiemens {
    #[inline]
    fn eq(&self, other: &UnitSiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitSiemens {
    fn default() -> Self {
        UnitSiemens
    }
}
impl Add<UnitSiemens> for UnitSiemens {
    type Output = UnitSiemens;
    #[inline]
    fn add(self, _: UnitSiemens) -> Self::Output {
        UnitSiemens
    }
}
impl AddAssign<UnitSiemens> for UnitSiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitSiemens) {}
}
impl Sub<UnitSiemens> for UnitSiemens {
    type Output = UnitSiemens;
    #[inline]
    fn sub(self, _: UnitSiemens) -> Self::Output {
        UnitSiemens
    }
}
impl SubAssign<UnitSiemens> for UnitSiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitSiemens) {}
}
pub struct UnitSiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSiemensMul {
    #[inline]
    fn clone(&self) -> UnitSiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSiemensMul {
    #[inline]
    fn eq(&self, other: &UnitSiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitSiemensMul> for i8 {
    type Output = Quantity<i8, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for i16 {
    type Output = Quantity<i16, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for i32 {
    type Output = Quantity<i32, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for i64 {
    type Output = Quantity<i64, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for i128 {
    type Output = Quantity<i128, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for isize {
    type Output = Quantity<isize, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for u8 {
    type Output = Quantity<u8, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for u16 {
    type Output = Quantity<u16, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for u32 {
    type Output = Quantity<u32, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for u64 {
    type Output = Quantity<u64, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for u128 {
    type Output = Quantity<u128, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for usize {
    type Output = Quantity<usize, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for f32 {
    type Output = Quantity<f32, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
impl Mul<UnitSiemensMul> for f64 {
    type Output = Quantity<f64, UnitSiemens>;
    fn mul(self, _: UnitSiemensMul) -> Self::Output {
        Quantity::new(self, UnitSiemens)
    }
}
pub struct UnitQuettasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasiemens {
    #[inline]
    fn clone(&self) -> UnitQuettasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasiemens {
    #[inline]
    fn eq(&self, other: &UnitQuettasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettasiemens {
    fn default() -> Self {
        UnitQuettasiemens
    }
}
impl Add<UnitQuettasiemens> for UnitQuettasiemens {
    type Output = UnitQuettasiemens;
    #[inline]
    fn add(self, _: UnitQuettasiemens) -> Self::Output {
        UnitQuettasiemens
    }
}
impl AddAssign<UnitQuettasiemens> for UnitQuettasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettasiemens) {}
}
impl Sub<UnitQuettasiemens> for UnitQuettasiemens {
    type Output = UnitQuettasiemens;
    #[inline]
    fn sub(self, _: UnitQuettasiemens) -> Self::Output {
        UnitQuettasiemens
    }
}
impl SubAssign<UnitQuettasiemens> for UnitQuettasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettasiemens) {}
}
pub struct UnitQuettasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasiemensMul {
    #[inline]
    fn clone(&self) -> UnitQuettasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitQuettasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettasiemensMul> for i8 {
    type Output = Quantity<i8, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for i16 {
    type Output = Quantity<i16, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for i32 {
    type Output = Quantity<i32, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for i64 {
    type Output = Quantity<i64, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for i128 {
    type Output = Quantity<i128, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for isize {
    type Output = Quantity<isize, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for u8 {
    type Output = Quantity<u8, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for u16 {
    type Output = Quantity<u16, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for u32 {
    type Output = Quantity<u32, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for u64 {
    type Output = Quantity<u64, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for u128 {
    type Output = Quantity<u128, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for usize {
    type Output = Quantity<usize, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for f32 {
    type Output = Quantity<f32, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
impl Mul<UnitQuettasiemensMul> for f64 {
    type Output = Quantity<f64, UnitQuettasiemens>;
    fn mul(self, _: UnitQuettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuettasiemens)
    }
}
pub struct UnitRonnasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasiemens {
    #[inline]
    fn clone(&self) -> UnitRonnasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasiemens {
    #[inline]
    fn eq(&self, other: &UnitRonnasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnasiemens {
    fn default() -> Self {
        UnitRonnasiemens
    }
}
impl Add<UnitRonnasiemens> for UnitRonnasiemens {
    type Output = UnitRonnasiemens;
    #[inline]
    fn add(self, _: UnitRonnasiemens) -> Self::Output {
        UnitRonnasiemens
    }
}
impl AddAssign<UnitRonnasiemens> for UnitRonnasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnasiemens) {}
}
impl Sub<UnitRonnasiemens> for UnitRonnasiemens {
    type Output = UnitRonnasiemens;
    #[inline]
    fn sub(self, _: UnitRonnasiemens) -> Self::Output {
        UnitRonnasiemens
    }
}
impl SubAssign<UnitRonnasiemens> for UnitRonnasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnasiemens) {}
}
pub struct UnitRonnasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasiemensMul {
    #[inline]
    fn clone(&self) -> UnitRonnasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitRonnasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnasiemensMul> for i8 {
    type Output = Quantity<i8, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for i16 {
    type Output = Quantity<i16, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for i32 {
    type Output = Quantity<i32, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for i64 {
    type Output = Quantity<i64, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for i128 {
    type Output = Quantity<i128, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for isize {
    type Output = Quantity<isize, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for u8 {
    type Output = Quantity<u8, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for u16 {
    type Output = Quantity<u16, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for u32 {
    type Output = Quantity<u32, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for u64 {
    type Output = Quantity<u64, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for u128 {
    type Output = Quantity<u128, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for usize {
    type Output = Quantity<usize, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for f32 {
    type Output = Quantity<f32, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
impl Mul<UnitRonnasiemensMul> for f64 {
    type Output = Quantity<f64, UnitRonnasiemens>;
    fn mul(self, _: UnitRonnasiemensMul) -> Self::Output {
        Quantity::new(self, UnitRonnasiemens)
    }
}
pub struct UnitYottasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasiemens {
    #[inline]
    fn clone(&self) -> UnitYottasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasiemens {
    #[inline]
    fn eq(&self, other: &UnitYottasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottasiemens {
    fn default() -> Self {
        UnitYottasiemens
    }
}
impl Add<UnitYottasiemens> for UnitYottasiemens {
    type Output = UnitYottasiemens;
    #[inline]
    fn add(self, _: UnitYottasiemens) -> Self::Output {
        UnitYottasiemens
    }
}
impl AddAssign<UnitYottasiemens> for UnitYottasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitYottasiemens) {}
}
impl Sub<UnitYottasiemens> for UnitYottasiemens {
    type Output = UnitYottasiemens;
    #[inline]
    fn sub(self, _: UnitYottasiemens) -> Self::Output {
        UnitYottasiemens
    }
}
impl SubAssign<UnitYottasiemens> for UnitYottasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottasiemens) {}
}
pub struct UnitYottasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasiemensMul {
    #[inline]
    fn clone(&self) -> UnitYottasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitYottasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottasiemensMul> for i8 {
    type Output = Quantity<i8, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for i16 {
    type Output = Quantity<i16, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for i32 {
    type Output = Quantity<i32, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for i64 {
    type Output = Quantity<i64, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for i128 {
    type Output = Quantity<i128, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for isize {
    type Output = Quantity<isize, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for u8 {
    type Output = Quantity<u8, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for u16 {
    type Output = Quantity<u16, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for u32 {
    type Output = Quantity<u32, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for u64 {
    type Output = Quantity<u64, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for u128 {
    type Output = Quantity<u128, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for usize {
    type Output = Quantity<usize, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for f32 {
    type Output = Quantity<f32, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
impl Mul<UnitYottasiemensMul> for f64 {
    type Output = Quantity<f64, UnitYottasiemens>;
    fn mul(self, _: UnitYottasiemensMul) -> Self::Output {
        Quantity::new(self, UnitYottasiemens)
    }
}
pub struct UnitZettasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasiemens {
    #[inline]
    fn clone(&self) -> UnitZettasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasiemens {
    #[inline]
    fn eq(&self, other: &UnitZettasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettasiemens {
    fn default() -> Self {
        UnitZettasiemens
    }
}
impl Add<UnitZettasiemens> for UnitZettasiemens {
    type Output = UnitZettasiemens;
    #[inline]
    fn add(self, _: UnitZettasiemens) -> Self::Output {
        UnitZettasiemens
    }
}
impl AddAssign<UnitZettasiemens> for UnitZettasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitZettasiemens) {}
}
impl Sub<UnitZettasiemens> for UnitZettasiemens {
    type Output = UnitZettasiemens;
    #[inline]
    fn sub(self, _: UnitZettasiemens) -> Self::Output {
        UnitZettasiemens
    }
}
impl SubAssign<UnitZettasiemens> for UnitZettasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettasiemens) {}
}
pub struct UnitZettasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasiemensMul {
    #[inline]
    fn clone(&self) -> UnitZettasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitZettasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettasiemensMul> for i8 {
    type Output = Quantity<i8, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for i16 {
    type Output = Quantity<i16, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for i32 {
    type Output = Quantity<i32, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for i64 {
    type Output = Quantity<i64, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for i128 {
    type Output = Quantity<i128, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for isize {
    type Output = Quantity<isize, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for u8 {
    type Output = Quantity<u8, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for u16 {
    type Output = Quantity<u16, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for u32 {
    type Output = Quantity<u32, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for u64 {
    type Output = Quantity<u64, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for u128 {
    type Output = Quantity<u128, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for usize {
    type Output = Quantity<usize, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for f32 {
    type Output = Quantity<f32, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
impl Mul<UnitZettasiemensMul> for f64 {
    type Output = Quantity<f64, UnitZettasiemens>;
    fn mul(self, _: UnitZettasiemensMul) -> Self::Output {
        Quantity::new(self, UnitZettasiemens)
    }
}
pub struct UnitExasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasiemens {
    #[inline]
    fn clone(&self) -> UnitExasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasiemens {
    #[inline]
    fn eq(&self, other: &UnitExasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExasiemens {
    fn default() -> Self {
        UnitExasiemens
    }
}
impl Add<UnitExasiemens> for UnitExasiemens {
    type Output = UnitExasiemens;
    #[inline]
    fn add(self, _: UnitExasiemens) -> Self::Output {
        UnitExasiemens
    }
}
impl AddAssign<UnitExasiemens> for UnitExasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitExasiemens) {}
}
impl Sub<UnitExasiemens> for UnitExasiemens {
    type Output = UnitExasiemens;
    #[inline]
    fn sub(self, _: UnitExasiemens) -> Self::Output {
        UnitExasiemens
    }
}
impl SubAssign<UnitExasiemens> for UnitExasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitExasiemens) {}
}
pub struct UnitExasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasiemensMul {
    #[inline]
    fn clone(&self) -> UnitExasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitExasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExasiemensMul> for i8 {
    type Output = Quantity<i8, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for i16 {
    type Output = Quantity<i16, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for i32 {
    type Output = Quantity<i32, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for i64 {
    type Output = Quantity<i64, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for i128 {
    type Output = Quantity<i128, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for isize {
    type Output = Quantity<isize, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for u8 {
    type Output = Quantity<u8, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for u16 {
    type Output = Quantity<u16, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for u32 {
    type Output = Quantity<u32, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for u64 {
    type Output = Quantity<u64, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for u128 {
    type Output = Quantity<u128, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for usize {
    type Output = Quantity<usize, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for f32 {
    type Output = Quantity<f32, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
impl Mul<UnitExasiemensMul> for f64 {
    type Output = Quantity<f64, UnitExasiemens>;
    fn mul(self, _: UnitExasiemensMul) -> Self::Output {
        Quantity::new(self, UnitExasiemens)
    }
}
pub struct UnitPetasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasiemens {
    #[inline]
    fn clone(&self) -> UnitPetasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasiemens {
    #[inline]
    fn eq(&self, other: &UnitPetasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetasiemens {
    fn default() -> Self {
        UnitPetasiemens
    }
}
impl Add<UnitPetasiemens> for UnitPetasiemens {
    type Output = UnitPetasiemens;
    #[inline]
    fn add(self, _: UnitPetasiemens) -> Self::Output {
        UnitPetasiemens
    }
}
impl AddAssign<UnitPetasiemens> for UnitPetasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitPetasiemens) {}
}
impl Sub<UnitPetasiemens> for UnitPetasiemens {
    type Output = UnitPetasiemens;
    #[inline]
    fn sub(self, _: UnitPetasiemens) -> Self::Output {
        UnitPetasiemens
    }
}
impl SubAssign<UnitPetasiemens> for UnitPetasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetasiemens) {}
}
pub struct UnitPetasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasiemensMul {
    #[inline]
    fn clone(&self) -> UnitPetasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitPetasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetasiemensMul> for i8 {
    type Output = Quantity<i8, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for i16 {
    type Output = Quantity<i16, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for i32 {
    type Output = Quantity<i32, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for i64 {
    type Output = Quantity<i64, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for i128 {
    type Output = Quantity<i128, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for isize {
    type Output = Quantity<isize, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for u8 {
    type Output = Quantity<u8, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for u16 {
    type Output = Quantity<u16, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for u32 {
    type Output = Quantity<u32, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for u64 {
    type Output = Quantity<u64, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for u128 {
    type Output = Quantity<u128, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for usize {
    type Output = Quantity<usize, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for f32 {
    type Output = Quantity<f32, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
impl Mul<UnitPetasiemensMul> for f64 {
    type Output = Quantity<f64, UnitPetasiemens>;
    fn mul(self, _: UnitPetasiemensMul) -> Self::Output {
        Quantity::new(self, UnitPetasiemens)
    }
}
pub struct UnitTerasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasiemens {
    #[inline]
    fn clone(&self) -> UnitTerasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasiemens {
    #[inline]
    fn eq(&self, other: &UnitTerasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerasiemens {
    fn default() -> Self {
        UnitTerasiemens
    }
}
impl Add<UnitTerasiemens> for UnitTerasiemens {
    type Output = UnitTerasiemens;
    #[inline]
    fn add(self, _: UnitTerasiemens) -> Self::Output {
        UnitTerasiemens
    }
}
impl AddAssign<UnitTerasiemens> for UnitTerasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitTerasiemens) {}
}
impl Sub<UnitTerasiemens> for UnitTerasiemens {
    type Output = UnitTerasiemens;
    #[inline]
    fn sub(self, _: UnitTerasiemens) -> Self::Output {
        UnitTerasiemens
    }
}
impl SubAssign<UnitTerasiemens> for UnitTerasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerasiemens) {}
}
pub struct UnitTerasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasiemensMul {
    #[inline]
    fn clone(&self) -> UnitTerasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitTerasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerasiemensMul> for i8 {
    type Output = Quantity<i8, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for i16 {
    type Output = Quantity<i16, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for i32 {
    type Output = Quantity<i32, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for i64 {
    type Output = Quantity<i64, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for i128 {
    type Output = Quantity<i128, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for isize {
    type Output = Quantity<isize, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for u8 {
    type Output = Quantity<u8, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for u16 {
    type Output = Quantity<u16, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for u32 {
    type Output = Quantity<u32, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for u64 {
    type Output = Quantity<u64, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for u128 {
    type Output = Quantity<u128, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for usize {
    type Output = Quantity<usize, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for f32 {
    type Output = Quantity<f32, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
impl Mul<UnitTerasiemensMul> for f64 {
    type Output = Quantity<f64, UnitTerasiemens>;
    fn mul(self, _: UnitTerasiemensMul) -> Self::Output {
        Quantity::new(self, UnitTerasiemens)
    }
}
pub struct UnitGigasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasiemens {
    #[inline]
    fn clone(&self) -> UnitGigasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasiemens {
    #[inline]
    fn eq(&self, other: &UnitGigasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigasiemens {
    fn default() -> Self {
        UnitGigasiemens
    }
}
impl Add<UnitGigasiemens> for UnitGigasiemens {
    type Output = UnitGigasiemens;
    #[inline]
    fn add(self, _: UnitGigasiemens) -> Self::Output {
        UnitGigasiemens
    }
}
impl AddAssign<UnitGigasiemens> for UnitGigasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitGigasiemens) {}
}
impl Sub<UnitGigasiemens> for UnitGigasiemens {
    type Output = UnitGigasiemens;
    #[inline]
    fn sub(self, _: UnitGigasiemens) -> Self::Output {
        UnitGigasiemens
    }
}
impl SubAssign<UnitGigasiemens> for UnitGigasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigasiemens) {}
}
pub struct UnitGigasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasiemensMul {
    #[inline]
    fn clone(&self) -> UnitGigasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitGigasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigasiemensMul> for i8 {
    type Output = Quantity<i8, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for i16 {
    type Output = Quantity<i16, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for i32 {
    type Output = Quantity<i32, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for i64 {
    type Output = Quantity<i64, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for i128 {
    type Output = Quantity<i128, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for isize {
    type Output = Quantity<isize, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for u8 {
    type Output = Quantity<u8, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for u16 {
    type Output = Quantity<u16, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for u32 {
    type Output = Quantity<u32, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for u64 {
    type Output = Quantity<u64, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for u128 {
    type Output = Quantity<u128, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for usize {
    type Output = Quantity<usize, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for f32 {
    type Output = Quantity<f32, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
impl Mul<UnitGigasiemensMul> for f64 {
    type Output = Quantity<f64, UnitGigasiemens>;
    fn mul(self, _: UnitGigasiemensMul) -> Self::Output {
        Quantity::new(self, UnitGigasiemens)
    }
}
pub struct UnitMegasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasiemens {
    #[inline]
    fn clone(&self) -> UnitMegasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasiemens {
    #[inline]
    fn eq(&self, other: &UnitMegasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegasiemens {
    fn default() -> Self {
        UnitMegasiemens
    }
}
impl Add<UnitMegasiemens> for UnitMegasiemens {
    type Output = UnitMegasiemens;
    #[inline]
    fn add(self, _: UnitMegasiemens) -> Self::Output {
        UnitMegasiemens
    }
}
impl AddAssign<UnitMegasiemens> for UnitMegasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitMegasiemens) {}
}
impl Sub<UnitMegasiemens> for UnitMegasiemens {
    type Output = UnitMegasiemens;
    #[inline]
    fn sub(self, _: UnitMegasiemens) -> Self::Output {
        UnitMegasiemens
    }
}
impl SubAssign<UnitMegasiemens> for UnitMegasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegasiemens) {}
}
pub struct UnitMegasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasiemensMul {
    #[inline]
    fn clone(&self) -> UnitMegasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitMegasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegasiemensMul> for i8 {
    type Output = Quantity<i8, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for i16 {
    type Output = Quantity<i16, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for i32 {
    type Output = Quantity<i32, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for i64 {
    type Output = Quantity<i64, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for i128 {
    type Output = Quantity<i128, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for isize {
    type Output = Quantity<isize, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for u8 {
    type Output = Quantity<u8, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for u16 {
    type Output = Quantity<u16, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for u32 {
    type Output = Quantity<u32, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for u64 {
    type Output = Quantity<u64, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for u128 {
    type Output = Quantity<u128, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for usize {
    type Output = Quantity<usize, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for f32 {
    type Output = Quantity<f32, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
impl Mul<UnitMegasiemensMul> for f64 {
    type Output = Quantity<f64, UnitMegasiemens>;
    fn mul(self, _: UnitMegasiemensMul) -> Self::Output {
        Quantity::new(self, UnitMegasiemens)
    }
}
pub struct UnitKilosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosiemens {
    #[inline]
    fn clone(&self) -> UnitKilosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosiemens {
    #[inline]
    fn eq(&self, other: &UnitKilosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilosiemens {
    fn default() -> Self {
        UnitKilosiemens
    }
}
impl Add<UnitKilosiemens> for UnitKilosiemens {
    type Output = UnitKilosiemens;
    #[inline]
    fn add(self, _: UnitKilosiemens) -> Self::Output {
        UnitKilosiemens
    }
}
impl AddAssign<UnitKilosiemens> for UnitKilosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitKilosiemens) {}
}
impl Sub<UnitKilosiemens> for UnitKilosiemens {
    type Output = UnitKilosiemens;
    #[inline]
    fn sub(self, _: UnitKilosiemens) -> Self::Output {
        UnitKilosiemens
    }
}
impl SubAssign<UnitKilosiemens> for UnitKilosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilosiemens) {}
}
pub struct UnitKilosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosiemensMul {
    #[inline]
    fn clone(&self) -> UnitKilosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitKilosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilosiemensMul> for i8 {
    type Output = Quantity<i8, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for i16 {
    type Output = Quantity<i16, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for i32 {
    type Output = Quantity<i32, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for i64 {
    type Output = Quantity<i64, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for i128 {
    type Output = Quantity<i128, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for isize {
    type Output = Quantity<isize, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for u8 {
    type Output = Quantity<u8, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for u16 {
    type Output = Quantity<u16, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for u32 {
    type Output = Quantity<u32, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for u64 {
    type Output = Quantity<u64, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for u128 {
    type Output = Quantity<u128, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for usize {
    type Output = Quantity<usize, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for f32 {
    type Output = Quantity<f32, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
impl Mul<UnitKilosiemensMul> for f64 {
    type Output = Quantity<f64, UnitKilosiemens>;
    fn mul(self, _: UnitKilosiemensMul) -> Self::Output {
        Quantity::new(self, UnitKilosiemens)
    }
}
pub struct UnitHectosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosiemens {
    #[inline]
    fn clone(&self) -> UnitHectosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosiemens {
    #[inline]
    fn eq(&self, other: &UnitHectosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectosiemens {
    fn default() -> Self {
        UnitHectosiemens
    }
}
impl Add<UnitHectosiemens> for UnitHectosiemens {
    type Output = UnitHectosiemens;
    #[inline]
    fn add(self, _: UnitHectosiemens) -> Self::Output {
        UnitHectosiemens
    }
}
impl AddAssign<UnitHectosiemens> for UnitHectosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitHectosiemens) {}
}
impl Sub<UnitHectosiemens> for UnitHectosiemens {
    type Output = UnitHectosiemens;
    #[inline]
    fn sub(self, _: UnitHectosiemens) -> Self::Output {
        UnitHectosiemens
    }
}
impl SubAssign<UnitHectosiemens> for UnitHectosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectosiemens) {}
}
pub struct UnitHectosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosiemensMul {
    #[inline]
    fn clone(&self) -> UnitHectosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitHectosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectosiemensMul> for i8 {
    type Output = Quantity<i8, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for i16 {
    type Output = Quantity<i16, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for i32 {
    type Output = Quantity<i32, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for i64 {
    type Output = Quantity<i64, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for i128 {
    type Output = Quantity<i128, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for isize {
    type Output = Quantity<isize, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for u8 {
    type Output = Quantity<u8, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for u16 {
    type Output = Quantity<u16, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for u32 {
    type Output = Quantity<u32, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for u64 {
    type Output = Quantity<u64, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for u128 {
    type Output = Quantity<u128, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for usize {
    type Output = Quantity<usize, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for f32 {
    type Output = Quantity<f32, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
impl Mul<UnitHectosiemensMul> for f64 {
    type Output = Quantity<f64, UnitHectosiemens>;
    fn mul(self, _: UnitHectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitHectosiemens)
    }
}
pub struct UnitDecasiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasiemens {
    #[inline]
    fn clone(&self) -> UnitDecasiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasiemens {
    #[inline]
    fn eq(&self, other: &UnitDecasiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecasiemens {
    fn default() -> Self {
        UnitDecasiemens
    }
}
impl Add<UnitDecasiemens> for UnitDecasiemens {
    type Output = UnitDecasiemens;
    #[inline]
    fn add(self, _: UnitDecasiemens) -> Self::Output {
        UnitDecasiemens
    }
}
impl AddAssign<UnitDecasiemens> for UnitDecasiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitDecasiemens) {}
}
impl Sub<UnitDecasiemens> for UnitDecasiemens {
    type Output = UnitDecasiemens;
    #[inline]
    fn sub(self, _: UnitDecasiemens) -> Self::Output {
        UnitDecasiemens
    }
}
impl SubAssign<UnitDecasiemens> for UnitDecasiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecasiemens) {}
}
pub struct UnitDecasiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasiemensMul {
    #[inline]
    fn clone(&self) -> UnitDecasiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasiemensMul {
    #[inline]
    fn eq(&self, other: &UnitDecasiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecasiemensMul> for i8 {
    type Output = Quantity<i8, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for i16 {
    type Output = Quantity<i16, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for i32 {
    type Output = Quantity<i32, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for i64 {
    type Output = Quantity<i64, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for i128 {
    type Output = Quantity<i128, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for isize {
    type Output = Quantity<isize, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for u8 {
    type Output = Quantity<u8, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for u16 {
    type Output = Quantity<u16, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for u32 {
    type Output = Quantity<u32, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for u64 {
    type Output = Quantity<u64, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for u128 {
    type Output = Quantity<u128, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for usize {
    type Output = Quantity<usize, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for f32 {
    type Output = Quantity<f32, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
impl Mul<UnitDecasiemensMul> for f64 {
    type Output = Quantity<f64, UnitDecasiemens>;
    fn mul(self, _: UnitDecasiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecasiemens)
    }
}
pub struct UnitDecisiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisiemens {
    #[inline]
    fn clone(&self) -> UnitDecisiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisiemens {
    #[inline]
    fn eq(&self, other: &UnitDecisiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecisiemens {
    fn default() -> Self {
        UnitDecisiemens
    }
}
impl Add<UnitDecisiemens> for UnitDecisiemens {
    type Output = UnitDecisiemens;
    #[inline]
    fn add(self, _: UnitDecisiemens) -> Self::Output {
        UnitDecisiemens
    }
}
impl AddAssign<UnitDecisiemens> for UnitDecisiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitDecisiemens) {}
}
impl Sub<UnitDecisiemens> for UnitDecisiemens {
    type Output = UnitDecisiemens;
    #[inline]
    fn sub(self, _: UnitDecisiemens) -> Self::Output {
        UnitDecisiemens
    }
}
impl SubAssign<UnitDecisiemens> for UnitDecisiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecisiemens) {}
}
pub struct UnitDecisiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisiemensMul {
    #[inline]
    fn clone(&self) -> UnitDecisiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisiemensMul {
    #[inline]
    fn eq(&self, other: &UnitDecisiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecisiemensMul> for i8 {
    type Output = Quantity<i8, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for i16 {
    type Output = Quantity<i16, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for i32 {
    type Output = Quantity<i32, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for i64 {
    type Output = Quantity<i64, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for i128 {
    type Output = Quantity<i128, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for isize {
    type Output = Quantity<isize, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for u8 {
    type Output = Quantity<u8, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for u16 {
    type Output = Quantity<u16, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for u32 {
    type Output = Quantity<u32, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for u64 {
    type Output = Quantity<u64, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for u128 {
    type Output = Quantity<u128, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for usize {
    type Output = Quantity<usize, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for f32 {
    type Output = Quantity<f32, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
impl Mul<UnitDecisiemensMul> for f64 {
    type Output = Quantity<f64, UnitDecisiemens>;
    fn mul(self, _: UnitDecisiemensMul) -> Self::Output {
        Quantity::new(self, UnitDecisiemens)
    }
}
pub struct UnitCentisiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisiemens {
    #[inline]
    fn clone(&self) -> UnitCentisiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisiemens {
    #[inline]
    fn eq(&self, other: &UnitCentisiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentisiemens {
    fn default() -> Self {
        UnitCentisiemens
    }
}
impl Add<UnitCentisiemens> for UnitCentisiemens {
    type Output = UnitCentisiemens;
    #[inline]
    fn add(self, _: UnitCentisiemens) -> Self::Output {
        UnitCentisiemens
    }
}
impl AddAssign<UnitCentisiemens> for UnitCentisiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitCentisiemens) {}
}
impl Sub<UnitCentisiemens> for UnitCentisiemens {
    type Output = UnitCentisiemens;
    #[inline]
    fn sub(self, _: UnitCentisiemens) -> Self::Output {
        UnitCentisiemens
    }
}
impl SubAssign<UnitCentisiemens> for UnitCentisiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentisiemens) {}
}
pub struct UnitCentisiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisiemensMul {
    #[inline]
    fn clone(&self) -> UnitCentisiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisiemensMul {
    #[inline]
    fn eq(&self, other: &UnitCentisiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentisiemensMul> for i8 {
    type Output = Quantity<i8, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for i16 {
    type Output = Quantity<i16, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for i32 {
    type Output = Quantity<i32, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for i64 {
    type Output = Quantity<i64, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for i128 {
    type Output = Quantity<i128, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for isize {
    type Output = Quantity<isize, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for u8 {
    type Output = Quantity<u8, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for u16 {
    type Output = Quantity<u16, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for u32 {
    type Output = Quantity<u32, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for u64 {
    type Output = Quantity<u64, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for u128 {
    type Output = Quantity<u128, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for usize {
    type Output = Quantity<usize, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for f32 {
    type Output = Quantity<f32, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
impl Mul<UnitCentisiemensMul> for f64 {
    type Output = Quantity<f64, UnitCentisiemens>;
    fn mul(self, _: UnitCentisiemensMul) -> Self::Output {
        Quantity::new(self, UnitCentisiemens)
    }
}
pub struct UnitMillisiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisiemens {
    #[inline]
    fn clone(&self) -> UnitMillisiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisiemens {
    #[inline]
    fn eq(&self, other: &UnitMillisiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillisiemens {
    fn default() -> Self {
        UnitMillisiemens
    }
}
impl Add<UnitMillisiemens> for UnitMillisiemens {
    type Output = UnitMillisiemens;
    #[inline]
    fn add(self, _: UnitMillisiemens) -> Self::Output {
        UnitMillisiemens
    }
}
impl AddAssign<UnitMillisiemens> for UnitMillisiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitMillisiemens) {}
}
impl Sub<UnitMillisiemens> for UnitMillisiemens {
    type Output = UnitMillisiemens;
    #[inline]
    fn sub(self, _: UnitMillisiemens) -> Self::Output {
        UnitMillisiemens
    }
}
impl SubAssign<UnitMillisiemens> for UnitMillisiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillisiemens) {}
}
pub struct UnitMillisiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisiemensMul {
    #[inline]
    fn clone(&self) -> UnitMillisiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisiemensMul {
    #[inline]
    fn eq(&self, other: &UnitMillisiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillisiemensMul> for i8 {
    type Output = Quantity<i8, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for i16 {
    type Output = Quantity<i16, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for i32 {
    type Output = Quantity<i32, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for i64 {
    type Output = Quantity<i64, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for i128 {
    type Output = Quantity<i128, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for isize {
    type Output = Quantity<isize, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for u8 {
    type Output = Quantity<u8, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for u16 {
    type Output = Quantity<u16, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for u32 {
    type Output = Quantity<u32, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for u64 {
    type Output = Quantity<u64, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for u128 {
    type Output = Quantity<u128, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for usize {
    type Output = Quantity<usize, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for f32 {
    type Output = Quantity<f32, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
impl Mul<UnitMillisiemensMul> for f64 {
    type Output = Quantity<f64, UnitMillisiemens>;
    fn mul(self, _: UnitMillisiemensMul) -> Self::Output {
        Quantity::new(self, UnitMillisiemens)
    }
}
pub struct UnitMicrosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosiemens {
    #[inline]
    fn clone(&self) -> UnitMicrosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosiemens {
    #[inline]
    fn eq(&self, other: &UnitMicrosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrosiemens {
    fn default() -> Self {
        UnitMicrosiemens
    }
}
impl Add<UnitMicrosiemens> for UnitMicrosiemens {
    type Output = UnitMicrosiemens;
    #[inline]
    fn add(self, _: UnitMicrosiemens) -> Self::Output {
        UnitMicrosiemens
    }
}
impl AddAssign<UnitMicrosiemens> for UnitMicrosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrosiemens) {}
}
impl Sub<UnitMicrosiemens> for UnitMicrosiemens {
    type Output = UnitMicrosiemens;
    #[inline]
    fn sub(self, _: UnitMicrosiemens) -> Self::Output {
        UnitMicrosiemens
    }
}
impl SubAssign<UnitMicrosiemens> for UnitMicrosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrosiemens) {}
}
pub struct UnitMicrosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosiemensMul {
    #[inline]
    fn clone(&self) -> UnitMicrosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitMicrosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrosiemensMul> for i8 {
    type Output = Quantity<i8, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for i16 {
    type Output = Quantity<i16, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for i32 {
    type Output = Quantity<i32, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for i64 {
    type Output = Quantity<i64, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for i128 {
    type Output = Quantity<i128, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for isize {
    type Output = Quantity<isize, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for u8 {
    type Output = Quantity<u8, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for u16 {
    type Output = Quantity<u16, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for u32 {
    type Output = Quantity<u32, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for u64 {
    type Output = Quantity<u64, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for u128 {
    type Output = Quantity<u128, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for usize {
    type Output = Quantity<usize, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for f32 {
    type Output = Quantity<f32, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
impl Mul<UnitMicrosiemensMul> for f64 {
    type Output = Quantity<f64, UnitMicrosiemens>;
    fn mul(self, _: UnitMicrosiemensMul) -> Self::Output {
        Quantity::new(self, UnitMicrosiemens)
    }
}
pub struct UnitNanosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosiemens {
    #[inline]
    fn clone(&self) -> UnitNanosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosiemens {
    #[inline]
    fn eq(&self, other: &UnitNanosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanosiemens {
    fn default() -> Self {
        UnitNanosiemens
    }
}
impl Add<UnitNanosiemens> for UnitNanosiemens {
    type Output = UnitNanosiemens;
    #[inline]
    fn add(self, _: UnitNanosiemens) -> Self::Output {
        UnitNanosiemens
    }
}
impl AddAssign<UnitNanosiemens> for UnitNanosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitNanosiemens) {}
}
impl Sub<UnitNanosiemens> for UnitNanosiemens {
    type Output = UnitNanosiemens;
    #[inline]
    fn sub(self, _: UnitNanosiemens) -> Self::Output {
        UnitNanosiemens
    }
}
impl SubAssign<UnitNanosiemens> for UnitNanosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanosiemens) {}
}
pub struct UnitNanosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosiemensMul {
    #[inline]
    fn clone(&self) -> UnitNanosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitNanosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanosiemensMul> for i8 {
    type Output = Quantity<i8, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for i16 {
    type Output = Quantity<i16, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for i32 {
    type Output = Quantity<i32, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for i64 {
    type Output = Quantity<i64, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for i128 {
    type Output = Quantity<i128, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for isize {
    type Output = Quantity<isize, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for u8 {
    type Output = Quantity<u8, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for u16 {
    type Output = Quantity<u16, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for u32 {
    type Output = Quantity<u32, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for u64 {
    type Output = Quantity<u64, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for u128 {
    type Output = Quantity<u128, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for usize {
    type Output = Quantity<usize, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for f32 {
    type Output = Quantity<f32, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
impl Mul<UnitNanosiemensMul> for f64 {
    type Output = Quantity<f64, UnitNanosiemens>;
    fn mul(self, _: UnitNanosiemensMul) -> Self::Output {
        Quantity::new(self, UnitNanosiemens)
    }
}
pub struct UnitPicosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosiemens {
    #[inline]
    fn clone(&self) -> UnitPicosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosiemens {
    #[inline]
    fn eq(&self, other: &UnitPicosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicosiemens {
    fn default() -> Self {
        UnitPicosiemens
    }
}
impl Add<UnitPicosiemens> for UnitPicosiemens {
    type Output = UnitPicosiemens;
    #[inline]
    fn add(self, _: UnitPicosiemens) -> Self::Output {
        UnitPicosiemens
    }
}
impl AddAssign<UnitPicosiemens> for UnitPicosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitPicosiemens) {}
}
impl Sub<UnitPicosiemens> for UnitPicosiemens {
    type Output = UnitPicosiemens;
    #[inline]
    fn sub(self, _: UnitPicosiemens) -> Self::Output {
        UnitPicosiemens
    }
}
impl SubAssign<UnitPicosiemens> for UnitPicosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicosiemens) {}
}
pub struct UnitPicosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosiemensMul {
    #[inline]
    fn clone(&self) -> UnitPicosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitPicosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicosiemensMul> for i8 {
    type Output = Quantity<i8, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for i16 {
    type Output = Quantity<i16, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for i32 {
    type Output = Quantity<i32, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for i64 {
    type Output = Quantity<i64, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for i128 {
    type Output = Quantity<i128, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for isize {
    type Output = Quantity<isize, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for u8 {
    type Output = Quantity<u8, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for u16 {
    type Output = Quantity<u16, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for u32 {
    type Output = Quantity<u32, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for u64 {
    type Output = Quantity<u64, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for u128 {
    type Output = Quantity<u128, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for usize {
    type Output = Quantity<usize, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for f32 {
    type Output = Quantity<f32, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
impl Mul<UnitPicosiemensMul> for f64 {
    type Output = Quantity<f64, UnitPicosiemens>;
    fn mul(self, _: UnitPicosiemensMul) -> Self::Output {
        Quantity::new(self, UnitPicosiemens)
    }
}
pub struct UnitFemtosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosiemens {
    #[inline]
    fn clone(&self) -> UnitFemtosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosiemens {
    #[inline]
    fn eq(&self, other: &UnitFemtosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtosiemens {
    fn default() -> Self {
        UnitFemtosiemens
    }
}
impl Add<UnitFemtosiemens> for UnitFemtosiemens {
    type Output = UnitFemtosiemens;
    #[inline]
    fn add(self, _: UnitFemtosiemens) -> Self::Output {
        UnitFemtosiemens
    }
}
impl AddAssign<UnitFemtosiemens> for UnitFemtosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtosiemens) {}
}
impl Sub<UnitFemtosiemens> for UnitFemtosiemens {
    type Output = UnitFemtosiemens;
    #[inline]
    fn sub(self, _: UnitFemtosiemens) -> Self::Output {
        UnitFemtosiemens
    }
}
impl SubAssign<UnitFemtosiemens> for UnitFemtosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtosiemens) {}
}
pub struct UnitFemtosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosiemensMul {
    #[inline]
    fn clone(&self) -> UnitFemtosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitFemtosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtosiemensMul> for i8 {
    type Output = Quantity<i8, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for i16 {
    type Output = Quantity<i16, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for i32 {
    type Output = Quantity<i32, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for i64 {
    type Output = Quantity<i64, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for i128 {
    type Output = Quantity<i128, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for isize {
    type Output = Quantity<isize, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for u8 {
    type Output = Quantity<u8, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for u16 {
    type Output = Quantity<u16, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for u32 {
    type Output = Quantity<u32, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for u64 {
    type Output = Quantity<u64, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for u128 {
    type Output = Quantity<u128, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for usize {
    type Output = Quantity<usize, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for f32 {
    type Output = Quantity<f32, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
impl Mul<UnitFemtosiemensMul> for f64 {
    type Output = Quantity<f64, UnitFemtosiemens>;
    fn mul(self, _: UnitFemtosiemensMul) -> Self::Output {
        Quantity::new(self, UnitFemtosiemens)
    }
}
pub struct UnitAttosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosiemens {
    #[inline]
    fn clone(&self) -> UnitAttosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosiemens {
    #[inline]
    fn eq(&self, other: &UnitAttosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttosiemens {
    fn default() -> Self {
        UnitAttosiemens
    }
}
impl Add<UnitAttosiemens> for UnitAttosiemens {
    type Output = UnitAttosiemens;
    #[inline]
    fn add(self, _: UnitAttosiemens) -> Self::Output {
        UnitAttosiemens
    }
}
impl AddAssign<UnitAttosiemens> for UnitAttosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitAttosiemens) {}
}
impl Sub<UnitAttosiemens> for UnitAttosiemens {
    type Output = UnitAttosiemens;
    #[inline]
    fn sub(self, _: UnitAttosiemens) -> Self::Output {
        UnitAttosiemens
    }
}
impl SubAssign<UnitAttosiemens> for UnitAttosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttosiemens) {}
}
pub struct UnitAttosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosiemensMul {
    #[inline]
    fn clone(&self) -> UnitAttosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitAttosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttosiemensMul> for i8 {
    type Output = Quantity<i8, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for i16 {
    type Output = Quantity<i16, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for i32 {
    type Output = Quantity<i32, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for i64 {
    type Output = Quantity<i64, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for i128 {
    type Output = Quantity<i128, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for isize {
    type Output = Quantity<isize, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for u8 {
    type Output = Quantity<u8, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for u16 {
    type Output = Quantity<u16, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for u32 {
    type Output = Quantity<u32, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for u64 {
    type Output = Quantity<u64, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for u128 {
    type Output = Quantity<u128, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for usize {
    type Output = Quantity<usize, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for f32 {
    type Output = Quantity<f32, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
impl Mul<UnitAttosiemensMul> for f64 {
    type Output = Quantity<f64, UnitAttosiemens>;
    fn mul(self, _: UnitAttosiemensMul) -> Self::Output {
        Quantity::new(self, UnitAttosiemens)
    }
}
pub struct UnitZeptosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosiemens {
    #[inline]
    fn clone(&self) -> UnitZeptosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosiemens {
    #[inline]
    fn eq(&self, other: &UnitZeptosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptosiemens {
    fn default() -> Self {
        UnitZeptosiemens
    }
}
impl Add<UnitZeptosiemens> for UnitZeptosiemens {
    type Output = UnitZeptosiemens;
    #[inline]
    fn add(self, _: UnitZeptosiemens) -> Self::Output {
        UnitZeptosiemens
    }
}
impl AddAssign<UnitZeptosiemens> for UnitZeptosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptosiemens) {}
}
impl Sub<UnitZeptosiemens> for UnitZeptosiemens {
    type Output = UnitZeptosiemens;
    #[inline]
    fn sub(self, _: UnitZeptosiemens) -> Self::Output {
        UnitZeptosiemens
    }
}
impl SubAssign<UnitZeptosiemens> for UnitZeptosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptosiemens) {}
}
pub struct UnitZeptosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosiemensMul {
    #[inline]
    fn clone(&self) -> UnitZeptosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitZeptosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptosiemensMul> for i8 {
    type Output = Quantity<i8, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for i16 {
    type Output = Quantity<i16, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for i32 {
    type Output = Quantity<i32, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for i64 {
    type Output = Quantity<i64, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for i128 {
    type Output = Quantity<i128, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for isize {
    type Output = Quantity<isize, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for u8 {
    type Output = Quantity<u8, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for u16 {
    type Output = Quantity<u16, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for u32 {
    type Output = Quantity<u32, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for u64 {
    type Output = Quantity<u64, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for u128 {
    type Output = Quantity<u128, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for usize {
    type Output = Quantity<usize, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for f32 {
    type Output = Quantity<f32, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
impl Mul<UnitZeptosiemensMul> for f64 {
    type Output = Quantity<f64, UnitZeptosiemens>;
    fn mul(self, _: UnitZeptosiemensMul) -> Self::Output {
        Quantity::new(self, UnitZeptosiemens)
    }
}
pub struct UnitYoctosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosiemens {
    #[inline]
    fn clone(&self) -> UnitYoctosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosiemens {
    #[inline]
    fn eq(&self, other: &UnitYoctosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctosiemens {
    fn default() -> Self {
        UnitYoctosiemens
    }
}
impl Add<UnitYoctosiemens> for UnitYoctosiemens {
    type Output = UnitYoctosiemens;
    #[inline]
    fn add(self, _: UnitYoctosiemens) -> Self::Output {
        UnitYoctosiemens
    }
}
impl AddAssign<UnitYoctosiemens> for UnitYoctosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctosiemens) {}
}
impl Sub<UnitYoctosiemens> for UnitYoctosiemens {
    type Output = UnitYoctosiemens;
    #[inline]
    fn sub(self, _: UnitYoctosiemens) -> Self::Output {
        UnitYoctosiemens
    }
}
impl SubAssign<UnitYoctosiemens> for UnitYoctosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctosiemens) {}
}
pub struct UnitYoctosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosiemensMul {
    #[inline]
    fn clone(&self) -> UnitYoctosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitYoctosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctosiemensMul> for i8 {
    type Output = Quantity<i8, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for i16 {
    type Output = Quantity<i16, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for i32 {
    type Output = Quantity<i32, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for i64 {
    type Output = Quantity<i64, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for i128 {
    type Output = Quantity<i128, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for isize {
    type Output = Quantity<isize, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for u8 {
    type Output = Quantity<u8, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for u16 {
    type Output = Quantity<u16, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for u32 {
    type Output = Quantity<u32, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for u64 {
    type Output = Quantity<u64, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for u128 {
    type Output = Quantity<u128, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for usize {
    type Output = Quantity<usize, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for f32 {
    type Output = Quantity<f32, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
impl Mul<UnitYoctosiemensMul> for f64 {
    type Output = Quantity<f64, UnitYoctosiemens>;
    fn mul(self, _: UnitYoctosiemensMul) -> Self::Output {
        Quantity::new(self, UnitYoctosiemens)
    }
}
pub struct UnitRontosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosiemens {
    #[inline]
    fn clone(&self) -> UnitRontosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosiemens {
    #[inline]
    fn eq(&self, other: &UnitRontosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontosiemens {
    fn default() -> Self {
        UnitRontosiemens
    }
}
impl Add<UnitRontosiemens> for UnitRontosiemens {
    type Output = UnitRontosiemens;
    #[inline]
    fn add(self, _: UnitRontosiemens) -> Self::Output {
        UnitRontosiemens
    }
}
impl AddAssign<UnitRontosiemens> for UnitRontosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitRontosiemens) {}
}
impl Sub<UnitRontosiemens> for UnitRontosiemens {
    type Output = UnitRontosiemens;
    #[inline]
    fn sub(self, _: UnitRontosiemens) -> Self::Output {
        UnitRontosiemens
    }
}
impl SubAssign<UnitRontosiemens> for UnitRontosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontosiemens) {}
}
pub struct UnitRontosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosiemensMul {
    #[inline]
    fn clone(&self) -> UnitRontosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitRontosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontosiemensMul> for i8 {
    type Output = Quantity<i8, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for i16 {
    type Output = Quantity<i16, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for i32 {
    type Output = Quantity<i32, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for i64 {
    type Output = Quantity<i64, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for i128 {
    type Output = Quantity<i128, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for isize {
    type Output = Quantity<isize, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for u8 {
    type Output = Quantity<u8, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for u16 {
    type Output = Quantity<u16, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for u32 {
    type Output = Quantity<u32, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for u64 {
    type Output = Quantity<u64, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for u128 {
    type Output = Quantity<u128, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for usize {
    type Output = Quantity<usize, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for f32 {
    type Output = Quantity<f32, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
impl Mul<UnitRontosiemensMul> for f64 {
    type Output = Quantity<f64, UnitRontosiemens>;
    fn mul(self, _: UnitRontosiemensMul) -> Self::Output {
        Quantity::new(self, UnitRontosiemens)
    }
}
pub struct UnitQuectosiemens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosiemens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosiemens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosiemens {
    #[inline]
    fn clone(&self) -> UnitQuectosiemens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosiemens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosiemens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosiemens {
    #[inline]
    fn eq(&self, other: &UnitQuectosiemens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosiemens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectosiemens {
    fn default() -> Self {
        UnitQuectosiemens
    }
}
impl Add<UnitQuectosiemens> for UnitQuectosiemens {
    type Output = UnitQuectosiemens;
    #[inline]
    fn add(self, _: UnitQuectosiemens) -> Self::Output {
        UnitQuectosiemens
    }
}
impl AddAssign<UnitQuectosiemens> for UnitQuectosiemens {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectosiemens) {}
}
impl Sub<UnitQuectosiemens> for UnitQuectosiemens {
    type Output = UnitQuectosiemens;
    #[inline]
    fn sub(self, _: UnitQuectosiemens) -> Self::Output {
        UnitQuectosiemens
    }
}
impl SubAssign<UnitQuectosiemens> for UnitQuectosiemens {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectosiemens) {}
}
pub struct UnitQuectosiemensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosiemensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosiemensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosiemensMul {
    #[inline]
    fn clone(&self) -> UnitQuectosiemensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosiemensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosiemensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosiemensMul {
    #[inline]
    fn eq(&self, other: &UnitQuectosiemensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosiemensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectosiemensMul> for i8 {
    type Output = Quantity<i8, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for i16 {
    type Output = Quantity<i16, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for i32 {
    type Output = Quantity<i32, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for i64 {
    type Output = Quantity<i64, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for i128 {
    type Output = Quantity<i128, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for isize {
    type Output = Quantity<isize, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for u8 {
    type Output = Quantity<u8, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for u16 {
    type Output = Quantity<u16, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for u32 {
    type Output = Quantity<u32, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for u64 {
    type Output = Quantity<u64, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for u128 {
    type Output = Quantity<u128, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for usize {
    type Output = Quantity<usize, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for f32 {
    type Output = Quantity<f32, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
impl Mul<UnitQuectosiemensMul> for f64 {
    type Output = Quantity<f64, UnitQuectosiemens>;
    fn mul(self, _: UnitQuectosiemensMul) -> Self::Output {
        Quantity::new(self, UnitQuectosiemens)
    }
}
pub type Siemens<T> = Quantity<T, UnitSiemens>;
#[allow(non_upper_case_globals)]
pub static Siemens: UnitSiemensMul = UnitSiemensMul;
pub type Quettasiemens<T> = Quantity<T, UnitQuettasiemens>;
#[allow(non_upper_case_globals)]
pub static Quettasiemens: UnitQuettasiemensMul = UnitQuettasiemensMul;
pub type Ronnasiemens<T> = Quantity<T, UnitRonnasiemens>;
#[allow(non_upper_case_globals)]
pub static Ronnasiemens: UnitRonnasiemensMul = UnitRonnasiemensMul;
pub type Yottasiemens<T> = Quantity<T, UnitYottasiemens>;
#[allow(non_upper_case_globals)]
pub static Yottasiemens: UnitYottasiemensMul = UnitYottasiemensMul;
pub type Zettasiemens<T> = Quantity<T, UnitZettasiemens>;
#[allow(non_upper_case_globals)]
pub static Zettasiemens: UnitZettasiemensMul = UnitZettasiemensMul;
pub type Exasiemens<T> = Quantity<T, UnitExasiemens>;
#[allow(non_upper_case_globals)]
pub static Exasiemens: UnitExasiemensMul = UnitExasiemensMul;
pub type Petasiemens<T> = Quantity<T, UnitPetasiemens>;
#[allow(non_upper_case_globals)]
pub static Petasiemens: UnitPetasiemensMul = UnitPetasiemensMul;
pub type Terasiemens<T> = Quantity<T, UnitTerasiemens>;
#[allow(non_upper_case_globals)]
pub static Terasiemens: UnitTerasiemensMul = UnitTerasiemensMul;
pub type Gigasiemens<T> = Quantity<T, UnitGigasiemens>;
#[allow(non_upper_case_globals)]
pub static Gigasiemens: UnitGigasiemensMul = UnitGigasiemensMul;
pub type Megasiemens<T> = Quantity<T, UnitMegasiemens>;
#[allow(non_upper_case_globals)]
pub static Megasiemens: UnitMegasiemensMul = UnitMegasiemensMul;
pub type Kilosiemens<T> = Quantity<T, UnitKilosiemens>;
#[allow(non_upper_case_globals)]
pub static Kilosiemens: UnitKilosiemensMul = UnitKilosiemensMul;
pub type Hectosiemens<T> = Quantity<T, UnitHectosiemens>;
#[allow(non_upper_case_globals)]
pub static Hectosiemens: UnitHectosiemensMul = UnitHectosiemensMul;
pub type Decasiemens<T> = Quantity<T, UnitDecasiemens>;
#[allow(non_upper_case_globals)]
pub static Decasiemens: UnitDecasiemensMul = UnitDecasiemensMul;
pub type Decisiemens<T> = Quantity<T, UnitDecisiemens>;
#[allow(non_upper_case_globals)]
pub static Decisiemens: UnitDecisiemensMul = UnitDecisiemensMul;
pub type Centisiemens<T> = Quantity<T, UnitCentisiemens>;
#[allow(non_upper_case_globals)]
pub static Centisiemens: UnitCentisiemensMul = UnitCentisiemensMul;
pub type Millisiemens<T> = Quantity<T, UnitMillisiemens>;
#[allow(non_upper_case_globals)]
pub static Millisiemens: UnitMillisiemensMul = UnitMillisiemensMul;
pub type Microsiemens<T> = Quantity<T, UnitMicrosiemens>;
#[allow(non_upper_case_globals)]
pub static Microsiemens: UnitMicrosiemensMul = UnitMicrosiemensMul;
pub type Nanosiemens<T> = Quantity<T, UnitNanosiemens>;
#[allow(non_upper_case_globals)]
pub static Nanosiemens: UnitNanosiemensMul = UnitNanosiemensMul;
pub type Picosiemens<T> = Quantity<T, UnitPicosiemens>;
#[allow(non_upper_case_globals)]
pub static Picosiemens: UnitPicosiemensMul = UnitPicosiemensMul;
pub type Femtosiemens<T> = Quantity<T, UnitFemtosiemens>;
#[allow(non_upper_case_globals)]
pub static Femtosiemens: UnitFemtosiemensMul = UnitFemtosiemensMul;
pub type Attosiemens<T> = Quantity<T, UnitAttosiemens>;
#[allow(non_upper_case_globals)]
pub static Attosiemens: UnitAttosiemensMul = UnitAttosiemensMul;
pub type Zeptosiemens<T> = Quantity<T, UnitZeptosiemens>;
#[allow(non_upper_case_globals)]
pub static Zeptosiemens: UnitZeptosiemensMul = UnitZeptosiemensMul;
pub type Yoctosiemens<T> = Quantity<T, UnitYoctosiemens>;
#[allow(non_upper_case_globals)]
pub static Yoctosiemens: UnitYoctosiemensMul = UnitYoctosiemensMul;
pub type Rontosiemens<T> = Quantity<T, UnitRontosiemens>;
#[allow(non_upper_case_globals)]
pub static Rontosiemens: UnitRontosiemensMul = UnitRontosiemensMul;
pub type Quectosiemens<T> = Quantity<T, UnitQuectosiemens>;
#[allow(non_upper_case_globals)]
pub static Quectosiemens: UnitQuectosiemensMul = UnitQuectosiemensMul;
pub struct UnitWebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitWebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitWebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitWebers {
    #[inline]
    fn clone(&self) -> UnitWebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitWebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitWebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitWebers {
    #[inline]
    fn eq(&self, other: &UnitWebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitWebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitWebers {
    fn default() -> Self {
        UnitWebers
    }
}
impl Add<UnitWebers> for UnitWebers {
    type Output = UnitWebers;
    #[inline]
    fn add(self, _: UnitWebers) -> Self::Output {
        UnitWebers
    }
}
impl AddAssign<UnitWebers> for UnitWebers {
    #[inline]
    fn add_assign(&mut self, _: UnitWebers) {}
}
impl Sub<UnitWebers> for UnitWebers {
    type Output = UnitWebers;
    #[inline]
    fn sub(self, _: UnitWebers) -> Self::Output {
        UnitWebers
    }
}
impl SubAssign<UnitWebers> for UnitWebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitWebers) {}
}
pub struct UnitWebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitWebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitWebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitWebersMul {
    #[inline]
    fn clone(&self) -> UnitWebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitWebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitWebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitWebersMul {
    #[inline]
    fn eq(&self, other: &UnitWebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitWebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitWebersMul> for i8 {
    type Output = Quantity<i8, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for i16 {
    type Output = Quantity<i16, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for i32 {
    type Output = Quantity<i32, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for i64 {
    type Output = Quantity<i64, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for i128 {
    type Output = Quantity<i128, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for isize {
    type Output = Quantity<isize, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for u8 {
    type Output = Quantity<u8, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for u16 {
    type Output = Quantity<u16, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for u32 {
    type Output = Quantity<u32, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for u64 {
    type Output = Quantity<u64, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for u128 {
    type Output = Quantity<u128, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for usize {
    type Output = Quantity<usize, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for f32 {
    type Output = Quantity<f32, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
impl Mul<UnitWebersMul> for f64 {
    type Output = Quantity<f64, UnitWebers>;
    fn mul(self, _: UnitWebersMul) -> Self::Output {
        Quantity::new(self, UnitWebers)
    }
}
pub struct UnitQuettawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettawebers {
    #[inline]
    fn clone(&self) -> UnitQuettawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettawebers {
    #[inline]
    fn eq(&self, other: &UnitQuettawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettawebers {
    fn default() -> Self {
        UnitQuettawebers
    }
}
impl Add<UnitQuettawebers> for UnitQuettawebers {
    type Output = UnitQuettawebers;
    #[inline]
    fn add(self, _: UnitQuettawebers) -> Self::Output {
        UnitQuettawebers
    }
}
impl AddAssign<UnitQuettawebers> for UnitQuettawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettawebers) {}
}
impl Sub<UnitQuettawebers> for UnitQuettawebers {
    type Output = UnitQuettawebers;
    #[inline]
    fn sub(self, _: UnitQuettawebers) -> Self::Output {
        UnitQuettawebers
    }
}
impl SubAssign<UnitQuettawebers> for UnitQuettawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettawebers) {}
}
pub struct UnitQuettawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettawebersMul {
    #[inline]
    fn clone(&self) -> UnitQuettawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettawebersMul {
    #[inline]
    fn eq(&self, other: &UnitQuettawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettawebersMul> for i8 {
    type Output = Quantity<i8, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for i16 {
    type Output = Quantity<i16, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for i32 {
    type Output = Quantity<i32, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for i64 {
    type Output = Quantity<i64, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for i128 {
    type Output = Quantity<i128, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for isize {
    type Output = Quantity<isize, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for u8 {
    type Output = Quantity<u8, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for u16 {
    type Output = Quantity<u16, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for u32 {
    type Output = Quantity<u32, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for u64 {
    type Output = Quantity<u64, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for u128 {
    type Output = Quantity<u128, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for usize {
    type Output = Quantity<usize, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for f32 {
    type Output = Quantity<f32, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
impl Mul<UnitQuettawebersMul> for f64 {
    type Output = Quantity<f64, UnitQuettawebers>;
    fn mul(self, _: UnitQuettawebersMul) -> Self::Output {
        Quantity::new(self, UnitQuettawebers)
    }
}
pub struct UnitRonnawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnawebers {
    #[inline]
    fn clone(&self) -> UnitRonnawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnawebers {
    #[inline]
    fn eq(&self, other: &UnitRonnawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnawebers {
    fn default() -> Self {
        UnitRonnawebers
    }
}
impl Add<UnitRonnawebers> for UnitRonnawebers {
    type Output = UnitRonnawebers;
    #[inline]
    fn add(self, _: UnitRonnawebers) -> Self::Output {
        UnitRonnawebers
    }
}
impl AddAssign<UnitRonnawebers> for UnitRonnawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnawebers) {}
}
impl Sub<UnitRonnawebers> for UnitRonnawebers {
    type Output = UnitRonnawebers;
    #[inline]
    fn sub(self, _: UnitRonnawebers) -> Self::Output {
        UnitRonnawebers
    }
}
impl SubAssign<UnitRonnawebers> for UnitRonnawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnawebers) {}
}
pub struct UnitRonnawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnawebersMul {
    #[inline]
    fn clone(&self) -> UnitRonnawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnawebersMul {
    #[inline]
    fn eq(&self, other: &UnitRonnawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnawebersMul> for i8 {
    type Output = Quantity<i8, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for i16 {
    type Output = Quantity<i16, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for i32 {
    type Output = Quantity<i32, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for i64 {
    type Output = Quantity<i64, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for i128 {
    type Output = Quantity<i128, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for isize {
    type Output = Quantity<isize, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for u8 {
    type Output = Quantity<u8, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for u16 {
    type Output = Quantity<u16, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for u32 {
    type Output = Quantity<u32, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for u64 {
    type Output = Quantity<u64, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for u128 {
    type Output = Quantity<u128, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for usize {
    type Output = Quantity<usize, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for f32 {
    type Output = Quantity<f32, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
impl Mul<UnitRonnawebersMul> for f64 {
    type Output = Quantity<f64, UnitRonnawebers>;
    fn mul(self, _: UnitRonnawebersMul) -> Self::Output {
        Quantity::new(self, UnitRonnawebers)
    }
}
pub struct UnitYottawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottawebers {
    #[inline]
    fn clone(&self) -> UnitYottawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottawebers {
    #[inline]
    fn eq(&self, other: &UnitYottawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottawebers {
    fn default() -> Self {
        UnitYottawebers
    }
}
impl Add<UnitYottawebers> for UnitYottawebers {
    type Output = UnitYottawebers;
    #[inline]
    fn add(self, _: UnitYottawebers) -> Self::Output {
        UnitYottawebers
    }
}
impl AddAssign<UnitYottawebers> for UnitYottawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitYottawebers) {}
}
impl Sub<UnitYottawebers> for UnitYottawebers {
    type Output = UnitYottawebers;
    #[inline]
    fn sub(self, _: UnitYottawebers) -> Self::Output {
        UnitYottawebers
    }
}
impl SubAssign<UnitYottawebers> for UnitYottawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottawebers) {}
}
pub struct UnitYottawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottawebersMul {
    #[inline]
    fn clone(&self) -> UnitYottawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottawebersMul {
    #[inline]
    fn eq(&self, other: &UnitYottawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottawebersMul> for i8 {
    type Output = Quantity<i8, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for i16 {
    type Output = Quantity<i16, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for i32 {
    type Output = Quantity<i32, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for i64 {
    type Output = Quantity<i64, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for i128 {
    type Output = Quantity<i128, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for isize {
    type Output = Quantity<isize, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for u8 {
    type Output = Quantity<u8, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for u16 {
    type Output = Quantity<u16, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for u32 {
    type Output = Quantity<u32, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for u64 {
    type Output = Quantity<u64, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for u128 {
    type Output = Quantity<u128, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for usize {
    type Output = Quantity<usize, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for f32 {
    type Output = Quantity<f32, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
impl Mul<UnitYottawebersMul> for f64 {
    type Output = Quantity<f64, UnitYottawebers>;
    fn mul(self, _: UnitYottawebersMul) -> Self::Output {
        Quantity::new(self, UnitYottawebers)
    }
}
pub struct UnitZettawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettawebers {
    #[inline]
    fn clone(&self) -> UnitZettawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettawebers {
    #[inline]
    fn eq(&self, other: &UnitZettawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettawebers {
    fn default() -> Self {
        UnitZettawebers
    }
}
impl Add<UnitZettawebers> for UnitZettawebers {
    type Output = UnitZettawebers;
    #[inline]
    fn add(self, _: UnitZettawebers) -> Self::Output {
        UnitZettawebers
    }
}
impl AddAssign<UnitZettawebers> for UnitZettawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitZettawebers) {}
}
impl Sub<UnitZettawebers> for UnitZettawebers {
    type Output = UnitZettawebers;
    #[inline]
    fn sub(self, _: UnitZettawebers) -> Self::Output {
        UnitZettawebers
    }
}
impl SubAssign<UnitZettawebers> for UnitZettawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettawebers) {}
}
pub struct UnitZettawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettawebersMul {
    #[inline]
    fn clone(&self) -> UnitZettawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettawebersMul {
    #[inline]
    fn eq(&self, other: &UnitZettawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettawebersMul> for i8 {
    type Output = Quantity<i8, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for i16 {
    type Output = Quantity<i16, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for i32 {
    type Output = Quantity<i32, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for i64 {
    type Output = Quantity<i64, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for i128 {
    type Output = Quantity<i128, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for isize {
    type Output = Quantity<isize, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for u8 {
    type Output = Quantity<u8, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for u16 {
    type Output = Quantity<u16, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for u32 {
    type Output = Quantity<u32, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for u64 {
    type Output = Quantity<u64, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for u128 {
    type Output = Quantity<u128, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for usize {
    type Output = Quantity<usize, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for f32 {
    type Output = Quantity<f32, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
impl Mul<UnitZettawebersMul> for f64 {
    type Output = Quantity<f64, UnitZettawebers>;
    fn mul(self, _: UnitZettawebersMul) -> Self::Output {
        Quantity::new(self, UnitZettawebers)
    }
}
pub struct UnitExawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExawebers {
    #[inline]
    fn clone(&self) -> UnitExawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExawebers {
    #[inline]
    fn eq(&self, other: &UnitExawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExawebers {
    fn default() -> Self {
        UnitExawebers
    }
}
impl Add<UnitExawebers> for UnitExawebers {
    type Output = UnitExawebers;
    #[inline]
    fn add(self, _: UnitExawebers) -> Self::Output {
        UnitExawebers
    }
}
impl AddAssign<UnitExawebers> for UnitExawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitExawebers) {}
}
impl Sub<UnitExawebers> for UnitExawebers {
    type Output = UnitExawebers;
    #[inline]
    fn sub(self, _: UnitExawebers) -> Self::Output {
        UnitExawebers
    }
}
impl SubAssign<UnitExawebers> for UnitExawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitExawebers) {}
}
pub struct UnitExawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExawebersMul {
    #[inline]
    fn clone(&self) -> UnitExawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExawebersMul {
    #[inline]
    fn eq(&self, other: &UnitExawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExawebersMul> for i8 {
    type Output = Quantity<i8, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for i16 {
    type Output = Quantity<i16, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for i32 {
    type Output = Quantity<i32, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for i64 {
    type Output = Quantity<i64, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for i128 {
    type Output = Quantity<i128, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for isize {
    type Output = Quantity<isize, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for u8 {
    type Output = Quantity<u8, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for u16 {
    type Output = Quantity<u16, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for u32 {
    type Output = Quantity<u32, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for u64 {
    type Output = Quantity<u64, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for u128 {
    type Output = Quantity<u128, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for usize {
    type Output = Quantity<usize, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for f32 {
    type Output = Quantity<f32, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
impl Mul<UnitExawebersMul> for f64 {
    type Output = Quantity<f64, UnitExawebers>;
    fn mul(self, _: UnitExawebersMul) -> Self::Output {
        Quantity::new(self, UnitExawebers)
    }
}
pub struct UnitPetawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetawebers {
    #[inline]
    fn clone(&self) -> UnitPetawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetawebers {
    #[inline]
    fn eq(&self, other: &UnitPetawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetawebers {
    fn default() -> Self {
        UnitPetawebers
    }
}
impl Add<UnitPetawebers> for UnitPetawebers {
    type Output = UnitPetawebers;
    #[inline]
    fn add(self, _: UnitPetawebers) -> Self::Output {
        UnitPetawebers
    }
}
impl AddAssign<UnitPetawebers> for UnitPetawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitPetawebers) {}
}
impl Sub<UnitPetawebers> for UnitPetawebers {
    type Output = UnitPetawebers;
    #[inline]
    fn sub(self, _: UnitPetawebers) -> Self::Output {
        UnitPetawebers
    }
}
impl SubAssign<UnitPetawebers> for UnitPetawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetawebers) {}
}
pub struct UnitPetawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetawebersMul {
    #[inline]
    fn clone(&self) -> UnitPetawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetawebersMul {
    #[inline]
    fn eq(&self, other: &UnitPetawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetawebersMul> for i8 {
    type Output = Quantity<i8, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for i16 {
    type Output = Quantity<i16, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for i32 {
    type Output = Quantity<i32, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for i64 {
    type Output = Quantity<i64, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for i128 {
    type Output = Quantity<i128, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for isize {
    type Output = Quantity<isize, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for u8 {
    type Output = Quantity<u8, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for u16 {
    type Output = Quantity<u16, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for u32 {
    type Output = Quantity<u32, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for u64 {
    type Output = Quantity<u64, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for u128 {
    type Output = Quantity<u128, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for usize {
    type Output = Quantity<usize, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for f32 {
    type Output = Quantity<f32, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
impl Mul<UnitPetawebersMul> for f64 {
    type Output = Quantity<f64, UnitPetawebers>;
    fn mul(self, _: UnitPetawebersMul) -> Self::Output {
        Quantity::new(self, UnitPetawebers)
    }
}
pub struct UnitTerawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerawebers {
    #[inline]
    fn clone(&self) -> UnitTerawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerawebers {
    #[inline]
    fn eq(&self, other: &UnitTerawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerawebers {
    fn default() -> Self {
        UnitTerawebers
    }
}
impl Add<UnitTerawebers> for UnitTerawebers {
    type Output = UnitTerawebers;
    #[inline]
    fn add(self, _: UnitTerawebers) -> Self::Output {
        UnitTerawebers
    }
}
impl AddAssign<UnitTerawebers> for UnitTerawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitTerawebers) {}
}
impl Sub<UnitTerawebers> for UnitTerawebers {
    type Output = UnitTerawebers;
    #[inline]
    fn sub(self, _: UnitTerawebers) -> Self::Output {
        UnitTerawebers
    }
}
impl SubAssign<UnitTerawebers> for UnitTerawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerawebers) {}
}
pub struct UnitTerawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerawebersMul {
    #[inline]
    fn clone(&self) -> UnitTerawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerawebersMul {
    #[inline]
    fn eq(&self, other: &UnitTerawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerawebersMul> for i8 {
    type Output = Quantity<i8, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for i16 {
    type Output = Quantity<i16, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for i32 {
    type Output = Quantity<i32, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for i64 {
    type Output = Quantity<i64, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for i128 {
    type Output = Quantity<i128, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for isize {
    type Output = Quantity<isize, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for u8 {
    type Output = Quantity<u8, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for u16 {
    type Output = Quantity<u16, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for u32 {
    type Output = Quantity<u32, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for u64 {
    type Output = Quantity<u64, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for u128 {
    type Output = Quantity<u128, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for usize {
    type Output = Quantity<usize, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for f32 {
    type Output = Quantity<f32, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
impl Mul<UnitTerawebersMul> for f64 {
    type Output = Quantity<f64, UnitTerawebers>;
    fn mul(self, _: UnitTerawebersMul) -> Self::Output {
        Quantity::new(self, UnitTerawebers)
    }
}
pub struct UnitGigawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigawebers {
    #[inline]
    fn clone(&self) -> UnitGigawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigawebers {
    #[inline]
    fn eq(&self, other: &UnitGigawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigawebers {
    fn default() -> Self {
        UnitGigawebers
    }
}
impl Add<UnitGigawebers> for UnitGigawebers {
    type Output = UnitGigawebers;
    #[inline]
    fn add(self, _: UnitGigawebers) -> Self::Output {
        UnitGigawebers
    }
}
impl AddAssign<UnitGigawebers> for UnitGigawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitGigawebers) {}
}
impl Sub<UnitGigawebers> for UnitGigawebers {
    type Output = UnitGigawebers;
    #[inline]
    fn sub(self, _: UnitGigawebers) -> Self::Output {
        UnitGigawebers
    }
}
impl SubAssign<UnitGigawebers> for UnitGigawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigawebers) {}
}
pub struct UnitGigawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigawebersMul {
    #[inline]
    fn clone(&self) -> UnitGigawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigawebersMul {
    #[inline]
    fn eq(&self, other: &UnitGigawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigawebersMul> for i8 {
    type Output = Quantity<i8, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for i16 {
    type Output = Quantity<i16, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for i32 {
    type Output = Quantity<i32, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for i64 {
    type Output = Quantity<i64, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for i128 {
    type Output = Quantity<i128, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for isize {
    type Output = Quantity<isize, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for u8 {
    type Output = Quantity<u8, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for u16 {
    type Output = Quantity<u16, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for u32 {
    type Output = Quantity<u32, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for u64 {
    type Output = Quantity<u64, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for u128 {
    type Output = Quantity<u128, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for usize {
    type Output = Quantity<usize, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for f32 {
    type Output = Quantity<f32, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
impl Mul<UnitGigawebersMul> for f64 {
    type Output = Quantity<f64, UnitGigawebers>;
    fn mul(self, _: UnitGigawebersMul) -> Self::Output {
        Quantity::new(self, UnitGigawebers)
    }
}
pub struct UnitMegawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegawebers {
    #[inline]
    fn clone(&self) -> UnitMegawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegawebers {
    #[inline]
    fn eq(&self, other: &UnitMegawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegawebers {
    fn default() -> Self {
        UnitMegawebers
    }
}
impl Add<UnitMegawebers> for UnitMegawebers {
    type Output = UnitMegawebers;
    #[inline]
    fn add(self, _: UnitMegawebers) -> Self::Output {
        UnitMegawebers
    }
}
impl AddAssign<UnitMegawebers> for UnitMegawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitMegawebers) {}
}
impl Sub<UnitMegawebers> for UnitMegawebers {
    type Output = UnitMegawebers;
    #[inline]
    fn sub(self, _: UnitMegawebers) -> Self::Output {
        UnitMegawebers
    }
}
impl SubAssign<UnitMegawebers> for UnitMegawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegawebers) {}
}
pub struct UnitMegawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegawebersMul {
    #[inline]
    fn clone(&self) -> UnitMegawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegawebersMul {
    #[inline]
    fn eq(&self, other: &UnitMegawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegawebersMul> for i8 {
    type Output = Quantity<i8, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for i16 {
    type Output = Quantity<i16, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for i32 {
    type Output = Quantity<i32, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for i64 {
    type Output = Quantity<i64, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for i128 {
    type Output = Quantity<i128, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for isize {
    type Output = Quantity<isize, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for u8 {
    type Output = Quantity<u8, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for u16 {
    type Output = Quantity<u16, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for u32 {
    type Output = Quantity<u32, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for u64 {
    type Output = Quantity<u64, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for u128 {
    type Output = Quantity<u128, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for usize {
    type Output = Quantity<usize, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for f32 {
    type Output = Quantity<f32, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
impl Mul<UnitMegawebersMul> for f64 {
    type Output = Quantity<f64, UnitMegawebers>;
    fn mul(self, _: UnitMegawebersMul) -> Self::Output {
        Quantity::new(self, UnitMegawebers)
    }
}
pub struct UnitKilowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilowebers {
    #[inline]
    fn clone(&self) -> UnitKilowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilowebers {
    #[inline]
    fn eq(&self, other: &UnitKilowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilowebers {
    fn default() -> Self {
        UnitKilowebers
    }
}
impl Add<UnitKilowebers> for UnitKilowebers {
    type Output = UnitKilowebers;
    #[inline]
    fn add(self, _: UnitKilowebers) -> Self::Output {
        UnitKilowebers
    }
}
impl AddAssign<UnitKilowebers> for UnitKilowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitKilowebers) {}
}
impl Sub<UnitKilowebers> for UnitKilowebers {
    type Output = UnitKilowebers;
    #[inline]
    fn sub(self, _: UnitKilowebers) -> Self::Output {
        UnitKilowebers
    }
}
impl SubAssign<UnitKilowebers> for UnitKilowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilowebers) {}
}
pub struct UnitKilowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilowebersMul {
    #[inline]
    fn clone(&self) -> UnitKilowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilowebersMul {
    #[inline]
    fn eq(&self, other: &UnitKilowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilowebersMul> for i8 {
    type Output = Quantity<i8, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for i16 {
    type Output = Quantity<i16, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for i32 {
    type Output = Quantity<i32, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for i64 {
    type Output = Quantity<i64, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for i128 {
    type Output = Quantity<i128, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for isize {
    type Output = Quantity<isize, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for u8 {
    type Output = Quantity<u8, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for u16 {
    type Output = Quantity<u16, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for u32 {
    type Output = Quantity<u32, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for u64 {
    type Output = Quantity<u64, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for u128 {
    type Output = Quantity<u128, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for usize {
    type Output = Quantity<usize, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for f32 {
    type Output = Quantity<f32, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
impl Mul<UnitKilowebersMul> for f64 {
    type Output = Quantity<f64, UnitKilowebers>;
    fn mul(self, _: UnitKilowebersMul) -> Self::Output {
        Quantity::new(self, UnitKilowebers)
    }
}
pub struct UnitHectowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectowebers {
    #[inline]
    fn clone(&self) -> UnitHectowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectowebers {
    #[inline]
    fn eq(&self, other: &UnitHectowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectowebers {
    fn default() -> Self {
        UnitHectowebers
    }
}
impl Add<UnitHectowebers> for UnitHectowebers {
    type Output = UnitHectowebers;
    #[inline]
    fn add(self, _: UnitHectowebers) -> Self::Output {
        UnitHectowebers
    }
}
impl AddAssign<UnitHectowebers> for UnitHectowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitHectowebers) {}
}
impl Sub<UnitHectowebers> for UnitHectowebers {
    type Output = UnitHectowebers;
    #[inline]
    fn sub(self, _: UnitHectowebers) -> Self::Output {
        UnitHectowebers
    }
}
impl SubAssign<UnitHectowebers> for UnitHectowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectowebers) {}
}
pub struct UnitHectowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectowebersMul {
    #[inline]
    fn clone(&self) -> UnitHectowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectowebersMul {
    #[inline]
    fn eq(&self, other: &UnitHectowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectowebersMul> for i8 {
    type Output = Quantity<i8, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for i16 {
    type Output = Quantity<i16, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for i32 {
    type Output = Quantity<i32, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for i64 {
    type Output = Quantity<i64, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for i128 {
    type Output = Quantity<i128, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for isize {
    type Output = Quantity<isize, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for u8 {
    type Output = Quantity<u8, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for u16 {
    type Output = Quantity<u16, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for u32 {
    type Output = Quantity<u32, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for u64 {
    type Output = Quantity<u64, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for u128 {
    type Output = Quantity<u128, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for usize {
    type Output = Quantity<usize, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for f32 {
    type Output = Quantity<f32, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
impl Mul<UnitHectowebersMul> for f64 {
    type Output = Quantity<f64, UnitHectowebers>;
    fn mul(self, _: UnitHectowebersMul) -> Self::Output {
        Quantity::new(self, UnitHectowebers)
    }
}
pub struct UnitDecawebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecawebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecawebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecawebers {
    #[inline]
    fn clone(&self) -> UnitDecawebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecawebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecawebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecawebers {
    #[inline]
    fn eq(&self, other: &UnitDecawebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecawebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecawebers {
    fn default() -> Self {
        UnitDecawebers
    }
}
impl Add<UnitDecawebers> for UnitDecawebers {
    type Output = UnitDecawebers;
    #[inline]
    fn add(self, _: UnitDecawebers) -> Self::Output {
        UnitDecawebers
    }
}
impl AddAssign<UnitDecawebers> for UnitDecawebers {
    #[inline]
    fn add_assign(&mut self, _: UnitDecawebers) {}
}
impl Sub<UnitDecawebers> for UnitDecawebers {
    type Output = UnitDecawebers;
    #[inline]
    fn sub(self, _: UnitDecawebers) -> Self::Output {
        UnitDecawebers
    }
}
impl SubAssign<UnitDecawebers> for UnitDecawebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecawebers) {}
}
pub struct UnitDecawebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecawebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecawebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecawebersMul {
    #[inline]
    fn clone(&self) -> UnitDecawebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecawebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecawebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecawebersMul {
    #[inline]
    fn eq(&self, other: &UnitDecawebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecawebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecawebersMul> for i8 {
    type Output = Quantity<i8, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for i16 {
    type Output = Quantity<i16, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for i32 {
    type Output = Quantity<i32, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for i64 {
    type Output = Quantity<i64, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for i128 {
    type Output = Quantity<i128, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for isize {
    type Output = Quantity<isize, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for u8 {
    type Output = Quantity<u8, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for u16 {
    type Output = Quantity<u16, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for u32 {
    type Output = Quantity<u32, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for u64 {
    type Output = Quantity<u64, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for u128 {
    type Output = Quantity<u128, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for usize {
    type Output = Quantity<usize, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for f32 {
    type Output = Quantity<f32, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
impl Mul<UnitDecawebersMul> for f64 {
    type Output = Quantity<f64, UnitDecawebers>;
    fn mul(self, _: UnitDecawebersMul) -> Self::Output {
        Quantity::new(self, UnitDecawebers)
    }
}
pub struct UnitDeciwebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciwebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciwebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciwebers {
    #[inline]
    fn clone(&self) -> UnitDeciwebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciwebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciwebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciwebers {
    #[inline]
    fn eq(&self, other: &UnitDeciwebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciwebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciwebers {
    fn default() -> Self {
        UnitDeciwebers
    }
}
impl Add<UnitDeciwebers> for UnitDeciwebers {
    type Output = UnitDeciwebers;
    #[inline]
    fn add(self, _: UnitDeciwebers) -> Self::Output {
        UnitDeciwebers
    }
}
impl AddAssign<UnitDeciwebers> for UnitDeciwebers {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciwebers) {}
}
impl Sub<UnitDeciwebers> for UnitDeciwebers {
    type Output = UnitDeciwebers;
    #[inline]
    fn sub(self, _: UnitDeciwebers) -> Self::Output {
        UnitDeciwebers
    }
}
impl SubAssign<UnitDeciwebers> for UnitDeciwebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciwebers) {}
}
pub struct UnitDeciwebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciwebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciwebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciwebersMul {
    #[inline]
    fn clone(&self) -> UnitDeciwebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciwebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciwebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciwebersMul {
    #[inline]
    fn eq(&self, other: &UnitDeciwebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciwebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciwebersMul> for i8 {
    type Output = Quantity<i8, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for i16 {
    type Output = Quantity<i16, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for i32 {
    type Output = Quantity<i32, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for i64 {
    type Output = Quantity<i64, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for i128 {
    type Output = Quantity<i128, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for isize {
    type Output = Quantity<isize, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for u8 {
    type Output = Quantity<u8, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for u16 {
    type Output = Quantity<u16, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for u32 {
    type Output = Quantity<u32, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for u64 {
    type Output = Quantity<u64, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for u128 {
    type Output = Quantity<u128, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for usize {
    type Output = Quantity<usize, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for f32 {
    type Output = Quantity<f32, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
impl Mul<UnitDeciwebersMul> for f64 {
    type Output = Quantity<f64, UnitDeciwebers>;
    fn mul(self, _: UnitDeciwebersMul) -> Self::Output {
        Quantity::new(self, UnitDeciwebers)
    }
}
pub struct UnitCentiwebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiwebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiwebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiwebers {
    #[inline]
    fn clone(&self) -> UnitCentiwebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiwebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiwebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiwebers {
    #[inline]
    fn eq(&self, other: &UnitCentiwebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiwebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiwebers {
    fn default() -> Self {
        UnitCentiwebers
    }
}
impl Add<UnitCentiwebers> for UnitCentiwebers {
    type Output = UnitCentiwebers;
    #[inline]
    fn add(self, _: UnitCentiwebers) -> Self::Output {
        UnitCentiwebers
    }
}
impl AddAssign<UnitCentiwebers> for UnitCentiwebers {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiwebers) {}
}
impl Sub<UnitCentiwebers> for UnitCentiwebers {
    type Output = UnitCentiwebers;
    #[inline]
    fn sub(self, _: UnitCentiwebers) -> Self::Output {
        UnitCentiwebers
    }
}
impl SubAssign<UnitCentiwebers> for UnitCentiwebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiwebers) {}
}
pub struct UnitCentiwebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiwebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiwebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiwebersMul {
    #[inline]
    fn clone(&self) -> UnitCentiwebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiwebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiwebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiwebersMul {
    #[inline]
    fn eq(&self, other: &UnitCentiwebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiwebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiwebersMul> for i8 {
    type Output = Quantity<i8, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for i16 {
    type Output = Quantity<i16, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for i32 {
    type Output = Quantity<i32, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for i64 {
    type Output = Quantity<i64, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for i128 {
    type Output = Quantity<i128, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for isize {
    type Output = Quantity<isize, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for u8 {
    type Output = Quantity<u8, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for u16 {
    type Output = Quantity<u16, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for u32 {
    type Output = Quantity<u32, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for u64 {
    type Output = Quantity<u64, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for u128 {
    type Output = Quantity<u128, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for usize {
    type Output = Quantity<usize, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for f32 {
    type Output = Quantity<f32, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
impl Mul<UnitCentiwebersMul> for f64 {
    type Output = Quantity<f64, UnitCentiwebers>;
    fn mul(self, _: UnitCentiwebersMul) -> Self::Output {
        Quantity::new(self, UnitCentiwebers)
    }
}
pub struct UnitMilliwebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliwebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliwebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliwebers {
    #[inline]
    fn clone(&self) -> UnitMilliwebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliwebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliwebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliwebers {
    #[inline]
    fn eq(&self, other: &UnitMilliwebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliwebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliwebers {
    fn default() -> Self {
        UnitMilliwebers
    }
}
impl Add<UnitMilliwebers> for UnitMilliwebers {
    type Output = UnitMilliwebers;
    #[inline]
    fn add(self, _: UnitMilliwebers) -> Self::Output {
        UnitMilliwebers
    }
}
impl AddAssign<UnitMilliwebers> for UnitMilliwebers {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliwebers) {}
}
impl Sub<UnitMilliwebers> for UnitMilliwebers {
    type Output = UnitMilliwebers;
    #[inline]
    fn sub(self, _: UnitMilliwebers) -> Self::Output {
        UnitMilliwebers
    }
}
impl SubAssign<UnitMilliwebers> for UnitMilliwebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliwebers) {}
}
pub struct UnitMilliwebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliwebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliwebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliwebersMul {
    #[inline]
    fn clone(&self) -> UnitMilliwebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliwebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliwebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliwebersMul {
    #[inline]
    fn eq(&self, other: &UnitMilliwebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliwebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliwebersMul> for i8 {
    type Output = Quantity<i8, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for i16 {
    type Output = Quantity<i16, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for i32 {
    type Output = Quantity<i32, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for i64 {
    type Output = Quantity<i64, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for i128 {
    type Output = Quantity<i128, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for isize {
    type Output = Quantity<isize, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for u8 {
    type Output = Quantity<u8, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for u16 {
    type Output = Quantity<u16, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for u32 {
    type Output = Quantity<u32, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for u64 {
    type Output = Quantity<u64, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for u128 {
    type Output = Quantity<u128, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for usize {
    type Output = Quantity<usize, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for f32 {
    type Output = Quantity<f32, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
impl Mul<UnitMilliwebersMul> for f64 {
    type Output = Quantity<f64, UnitMilliwebers>;
    fn mul(self, _: UnitMilliwebersMul) -> Self::Output {
        Quantity::new(self, UnitMilliwebers)
    }
}
pub struct UnitMicrowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrowebers {
    #[inline]
    fn clone(&self) -> UnitMicrowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrowebers {
    #[inline]
    fn eq(&self, other: &UnitMicrowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrowebers {
    fn default() -> Self {
        UnitMicrowebers
    }
}
impl Add<UnitMicrowebers> for UnitMicrowebers {
    type Output = UnitMicrowebers;
    #[inline]
    fn add(self, _: UnitMicrowebers) -> Self::Output {
        UnitMicrowebers
    }
}
impl AddAssign<UnitMicrowebers> for UnitMicrowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrowebers) {}
}
impl Sub<UnitMicrowebers> for UnitMicrowebers {
    type Output = UnitMicrowebers;
    #[inline]
    fn sub(self, _: UnitMicrowebers) -> Self::Output {
        UnitMicrowebers
    }
}
impl SubAssign<UnitMicrowebers> for UnitMicrowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrowebers) {}
}
pub struct UnitMicrowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrowebersMul {
    #[inline]
    fn clone(&self) -> UnitMicrowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrowebersMul {
    #[inline]
    fn eq(&self, other: &UnitMicrowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrowebersMul> for i8 {
    type Output = Quantity<i8, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for i16 {
    type Output = Quantity<i16, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for i32 {
    type Output = Quantity<i32, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for i64 {
    type Output = Quantity<i64, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for i128 {
    type Output = Quantity<i128, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for isize {
    type Output = Quantity<isize, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for u8 {
    type Output = Quantity<u8, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for u16 {
    type Output = Quantity<u16, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for u32 {
    type Output = Quantity<u32, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for u64 {
    type Output = Quantity<u64, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for u128 {
    type Output = Quantity<u128, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for usize {
    type Output = Quantity<usize, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for f32 {
    type Output = Quantity<f32, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
impl Mul<UnitMicrowebersMul> for f64 {
    type Output = Quantity<f64, UnitMicrowebers>;
    fn mul(self, _: UnitMicrowebersMul) -> Self::Output {
        Quantity::new(self, UnitMicrowebers)
    }
}
pub struct UnitNanowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanowebers {
    #[inline]
    fn clone(&self) -> UnitNanowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanowebers {
    #[inline]
    fn eq(&self, other: &UnitNanowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanowebers {
    fn default() -> Self {
        UnitNanowebers
    }
}
impl Add<UnitNanowebers> for UnitNanowebers {
    type Output = UnitNanowebers;
    #[inline]
    fn add(self, _: UnitNanowebers) -> Self::Output {
        UnitNanowebers
    }
}
impl AddAssign<UnitNanowebers> for UnitNanowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitNanowebers) {}
}
impl Sub<UnitNanowebers> for UnitNanowebers {
    type Output = UnitNanowebers;
    #[inline]
    fn sub(self, _: UnitNanowebers) -> Self::Output {
        UnitNanowebers
    }
}
impl SubAssign<UnitNanowebers> for UnitNanowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanowebers) {}
}
pub struct UnitNanowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanowebersMul {
    #[inline]
    fn clone(&self) -> UnitNanowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanowebersMul {
    #[inline]
    fn eq(&self, other: &UnitNanowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanowebersMul> for i8 {
    type Output = Quantity<i8, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for i16 {
    type Output = Quantity<i16, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for i32 {
    type Output = Quantity<i32, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for i64 {
    type Output = Quantity<i64, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for i128 {
    type Output = Quantity<i128, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for isize {
    type Output = Quantity<isize, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for u8 {
    type Output = Quantity<u8, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for u16 {
    type Output = Quantity<u16, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for u32 {
    type Output = Quantity<u32, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for u64 {
    type Output = Quantity<u64, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for u128 {
    type Output = Quantity<u128, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for usize {
    type Output = Quantity<usize, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for f32 {
    type Output = Quantity<f32, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
impl Mul<UnitNanowebersMul> for f64 {
    type Output = Quantity<f64, UnitNanowebers>;
    fn mul(self, _: UnitNanowebersMul) -> Self::Output {
        Quantity::new(self, UnitNanowebers)
    }
}
pub struct UnitPicowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicowebers {
    #[inline]
    fn clone(&self) -> UnitPicowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicowebers {
    #[inline]
    fn eq(&self, other: &UnitPicowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicowebers {
    fn default() -> Self {
        UnitPicowebers
    }
}
impl Add<UnitPicowebers> for UnitPicowebers {
    type Output = UnitPicowebers;
    #[inline]
    fn add(self, _: UnitPicowebers) -> Self::Output {
        UnitPicowebers
    }
}
impl AddAssign<UnitPicowebers> for UnitPicowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitPicowebers) {}
}
impl Sub<UnitPicowebers> for UnitPicowebers {
    type Output = UnitPicowebers;
    #[inline]
    fn sub(self, _: UnitPicowebers) -> Self::Output {
        UnitPicowebers
    }
}
impl SubAssign<UnitPicowebers> for UnitPicowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicowebers) {}
}
pub struct UnitPicowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicowebersMul {
    #[inline]
    fn clone(&self) -> UnitPicowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicowebersMul {
    #[inline]
    fn eq(&self, other: &UnitPicowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicowebersMul> for i8 {
    type Output = Quantity<i8, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for i16 {
    type Output = Quantity<i16, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for i32 {
    type Output = Quantity<i32, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for i64 {
    type Output = Quantity<i64, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for i128 {
    type Output = Quantity<i128, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for isize {
    type Output = Quantity<isize, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for u8 {
    type Output = Quantity<u8, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for u16 {
    type Output = Quantity<u16, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for u32 {
    type Output = Quantity<u32, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for u64 {
    type Output = Quantity<u64, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for u128 {
    type Output = Quantity<u128, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for usize {
    type Output = Quantity<usize, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for f32 {
    type Output = Quantity<f32, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
impl Mul<UnitPicowebersMul> for f64 {
    type Output = Quantity<f64, UnitPicowebers>;
    fn mul(self, _: UnitPicowebersMul) -> Self::Output {
        Quantity::new(self, UnitPicowebers)
    }
}
pub struct UnitFemtowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtowebers {
    #[inline]
    fn clone(&self) -> UnitFemtowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtowebers {
    #[inline]
    fn eq(&self, other: &UnitFemtowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtowebers {
    fn default() -> Self {
        UnitFemtowebers
    }
}
impl Add<UnitFemtowebers> for UnitFemtowebers {
    type Output = UnitFemtowebers;
    #[inline]
    fn add(self, _: UnitFemtowebers) -> Self::Output {
        UnitFemtowebers
    }
}
impl AddAssign<UnitFemtowebers> for UnitFemtowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtowebers) {}
}
impl Sub<UnitFemtowebers> for UnitFemtowebers {
    type Output = UnitFemtowebers;
    #[inline]
    fn sub(self, _: UnitFemtowebers) -> Self::Output {
        UnitFemtowebers
    }
}
impl SubAssign<UnitFemtowebers> for UnitFemtowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtowebers) {}
}
pub struct UnitFemtowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtowebersMul {
    #[inline]
    fn clone(&self) -> UnitFemtowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtowebersMul {
    #[inline]
    fn eq(&self, other: &UnitFemtowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtowebersMul> for i8 {
    type Output = Quantity<i8, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for i16 {
    type Output = Quantity<i16, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for i32 {
    type Output = Quantity<i32, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for i64 {
    type Output = Quantity<i64, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for i128 {
    type Output = Quantity<i128, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for isize {
    type Output = Quantity<isize, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for u8 {
    type Output = Quantity<u8, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for u16 {
    type Output = Quantity<u16, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for u32 {
    type Output = Quantity<u32, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for u64 {
    type Output = Quantity<u64, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for u128 {
    type Output = Quantity<u128, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for usize {
    type Output = Quantity<usize, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for f32 {
    type Output = Quantity<f32, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
impl Mul<UnitFemtowebersMul> for f64 {
    type Output = Quantity<f64, UnitFemtowebers>;
    fn mul(self, _: UnitFemtowebersMul) -> Self::Output {
        Quantity::new(self, UnitFemtowebers)
    }
}
pub struct UnitAttowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttowebers {
    #[inline]
    fn clone(&self) -> UnitAttowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttowebers {
    #[inline]
    fn eq(&self, other: &UnitAttowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttowebers {
    fn default() -> Self {
        UnitAttowebers
    }
}
impl Add<UnitAttowebers> for UnitAttowebers {
    type Output = UnitAttowebers;
    #[inline]
    fn add(self, _: UnitAttowebers) -> Self::Output {
        UnitAttowebers
    }
}
impl AddAssign<UnitAttowebers> for UnitAttowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitAttowebers) {}
}
impl Sub<UnitAttowebers> for UnitAttowebers {
    type Output = UnitAttowebers;
    #[inline]
    fn sub(self, _: UnitAttowebers) -> Self::Output {
        UnitAttowebers
    }
}
impl SubAssign<UnitAttowebers> for UnitAttowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttowebers) {}
}
pub struct UnitAttowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttowebersMul {
    #[inline]
    fn clone(&self) -> UnitAttowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttowebersMul {
    #[inline]
    fn eq(&self, other: &UnitAttowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttowebersMul> for i8 {
    type Output = Quantity<i8, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for i16 {
    type Output = Quantity<i16, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for i32 {
    type Output = Quantity<i32, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for i64 {
    type Output = Quantity<i64, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for i128 {
    type Output = Quantity<i128, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for isize {
    type Output = Quantity<isize, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for u8 {
    type Output = Quantity<u8, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for u16 {
    type Output = Quantity<u16, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for u32 {
    type Output = Quantity<u32, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for u64 {
    type Output = Quantity<u64, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for u128 {
    type Output = Quantity<u128, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for usize {
    type Output = Quantity<usize, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for f32 {
    type Output = Quantity<f32, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
impl Mul<UnitAttowebersMul> for f64 {
    type Output = Quantity<f64, UnitAttowebers>;
    fn mul(self, _: UnitAttowebersMul) -> Self::Output {
        Quantity::new(self, UnitAttowebers)
    }
}
pub struct UnitZeptowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptowebers {
    #[inline]
    fn clone(&self) -> UnitZeptowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptowebers {
    #[inline]
    fn eq(&self, other: &UnitZeptowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptowebers {
    fn default() -> Self {
        UnitZeptowebers
    }
}
impl Add<UnitZeptowebers> for UnitZeptowebers {
    type Output = UnitZeptowebers;
    #[inline]
    fn add(self, _: UnitZeptowebers) -> Self::Output {
        UnitZeptowebers
    }
}
impl AddAssign<UnitZeptowebers> for UnitZeptowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptowebers) {}
}
impl Sub<UnitZeptowebers> for UnitZeptowebers {
    type Output = UnitZeptowebers;
    #[inline]
    fn sub(self, _: UnitZeptowebers) -> Self::Output {
        UnitZeptowebers
    }
}
impl SubAssign<UnitZeptowebers> for UnitZeptowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptowebers) {}
}
pub struct UnitZeptowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptowebersMul {
    #[inline]
    fn clone(&self) -> UnitZeptowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptowebersMul {
    #[inline]
    fn eq(&self, other: &UnitZeptowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptowebersMul> for i8 {
    type Output = Quantity<i8, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for i16 {
    type Output = Quantity<i16, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for i32 {
    type Output = Quantity<i32, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for i64 {
    type Output = Quantity<i64, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for i128 {
    type Output = Quantity<i128, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for isize {
    type Output = Quantity<isize, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for u8 {
    type Output = Quantity<u8, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for u16 {
    type Output = Quantity<u16, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for u32 {
    type Output = Quantity<u32, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for u64 {
    type Output = Quantity<u64, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for u128 {
    type Output = Quantity<u128, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for usize {
    type Output = Quantity<usize, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for f32 {
    type Output = Quantity<f32, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
impl Mul<UnitZeptowebersMul> for f64 {
    type Output = Quantity<f64, UnitZeptowebers>;
    fn mul(self, _: UnitZeptowebersMul) -> Self::Output {
        Quantity::new(self, UnitZeptowebers)
    }
}
pub struct UnitYoctowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctowebers {
    #[inline]
    fn clone(&self) -> UnitYoctowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctowebers {
    #[inline]
    fn eq(&self, other: &UnitYoctowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctowebers {
    fn default() -> Self {
        UnitYoctowebers
    }
}
impl Add<UnitYoctowebers> for UnitYoctowebers {
    type Output = UnitYoctowebers;
    #[inline]
    fn add(self, _: UnitYoctowebers) -> Self::Output {
        UnitYoctowebers
    }
}
impl AddAssign<UnitYoctowebers> for UnitYoctowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctowebers) {}
}
impl Sub<UnitYoctowebers> for UnitYoctowebers {
    type Output = UnitYoctowebers;
    #[inline]
    fn sub(self, _: UnitYoctowebers) -> Self::Output {
        UnitYoctowebers
    }
}
impl SubAssign<UnitYoctowebers> for UnitYoctowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctowebers) {}
}
pub struct UnitYoctowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctowebersMul {
    #[inline]
    fn clone(&self) -> UnitYoctowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctowebersMul {
    #[inline]
    fn eq(&self, other: &UnitYoctowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctowebersMul> for i8 {
    type Output = Quantity<i8, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for i16 {
    type Output = Quantity<i16, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for i32 {
    type Output = Quantity<i32, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for i64 {
    type Output = Quantity<i64, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for i128 {
    type Output = Quantity<i128, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for isize {
    type Output = Quantity<isize, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for u8 {
    type Output = Quantity<u8, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for u16 {
    type Output = Quantity<u16, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for u32 {
    type Output = Quantity<u32, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for u64 {
    type Output = Quantity<u64, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for u128 {
    type Output = Quantity<u128, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for usize {
    type Output = Quantity<usize, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for f32 {
    type Output = Quantity<f32, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
impl Mul<UnitYoctowebersMul> for f64 {
    type Output = Quantity<f64, UnitYoctowebers>;
    fn mul(self, _: UnitYoctowebersMul) -> Self::Output {
        Quantity::new(self, UnitYoctowebers)
    }
}
pub struct UnitRontowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontowebers {
    #[inline]
    fn clone(&self) -> UnitRontowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontowebers {
    #[inline]
    fn eq(&self, other: &UnitRontowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontowebers {
    fn default() -> Self {
        UnitRontowebers
    }
}
impl Add<UnitRontowebers> for UnitRontowebers {
    type Output = UnitRontowebers;
    #[inline]
    fn add(self, _: UnitRontowebers) -> Self::Output {
        UnitRontowebers
    }
}
impl AddAssign<UnitRontowebers> for UnitRontowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitRontowebers) {}
}
impl Sub<UnitRontowebers> for UnitRontowebers {
    type Output = UnitRontowebers;
    #[inline]
    fn sub(self, _: UnitRontowebers) -> Self::Output {
        UnitRontowebers
    }
}
impl SubAssign<UnitRontowebers> for UnitRontowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontowebers) {}
}
pub struct UnitRontowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontowebersMul {
    #[inline]
    fn clone(&self) -> UnitRontowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontowebersMul {
    #[inline]
    fn eq(&self, other: &UnitRontowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontowebersMul> for i8 {
    type Output = Quantity<i8, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for i16 {
    type Output = Quantity<i16, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for i32 {
    type Output = Quantity<i32, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for i64 {
    type Output = Quantity<i64, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for i128 {
    type Output = Quantity<i128, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for isize {
    type Output = Quantity<isize, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for u8 {
    type Output = Quantity<u8, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for u16 {
    type Output = Quantity<u16, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for u32 {
    type Output = Quantity<u32, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for u64 {
    type Output = Quantity<u64, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for u128 {
    type Output = Quantity<u128, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for usize {
    type Output = Quantity<usize, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for f32 {
    type Output = Quantity<f32, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
impl Mul<UnitRontowebersMul> for f64 {
    type Output = Quantity<f64, UnitRontowebers>;
    fn mul(self, _: UnitRontowebersMul) -> Self::Output {
        Quantity::new(self, UnitRontowebers)
    }
}
pub struct UnitQuectowebers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectowebers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectowebers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectowebers {
    #[inline]
    fn clone(&self) -> UnitQuectowebers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectowebers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectowebers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectowebers {
    #[inline]
    fn eq(&self, other: &UnitQuectowebers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectowebers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectowebers {
    fn default() -> Self {
        UnitQuectowebers
    }
}
impl Add<UnitQuectowebers> for UnitQuectowebers {
    type Output = UnitQuectowebers;
    #[inline]
    fn add(self, _: UnitQuectowebers) -> Self::Output {
        UnitQuectowebers
    }
}
impl AddAssign<UnitQuectowebers> for UnitQuectowebers {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectowebers) {}
}
impl Sub<UnitQuectowebers> for UnitQuectowebers {
    type Output = UnitQuectowebers;
    #[inline]
    fn sub(self, _: UnitQuectowebers) -> Self::Output {
        UnitQuectowebers
    }
}
impl SubAssign<UnitQuectowebers> for UnitQuectowebers {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectowebers) {}
}
pub struct UnitQuectowebersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectowebersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectowebersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectowebersMul {
    #[inline]
    fn clone(&self) -> UnitQuectowebersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectowebersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectowebersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectowebersMul {
    #[inline]
    fn eq(&self, other: &UnitQuectowebersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectowebersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectowebersMul> for i8 {
    type Output = Quantity<i8, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for i16 {
    type Output = Quantity<i16, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for i32 {
    type Output = Quantity<i32, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for i64 {
    type Output = Quantity<i64, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for i128 {
    type Output = Quantity<i128, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for isize {
    type Output = Quantity<isize, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for u8 {
    type Output = Quantity<u8, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for u16 {
    type Output = Quantity<u16, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for u32 {
    type Output = Quantity<u32, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for u64 {
    type Output = Quantity<u64, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for u128 {
    type Output = Quantity<u128, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for usize {
    type Output = Quantity<usize, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for f32 {
    type Output = Quantity<f32, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
impl Mul<UnitQuectowebersMul> for f64 {
    type Output = Quantity<f64, UnitQuectowebers>;
    fn mul(self, _: UnitQuectowebersMul) -> Self::Output {
        Quantity::new(self, UnitQuectowebers)
    }
}
pub type Webers<T> = Quantity<T, UnitWebers>;
#[allow(non_upper_case_globals)]
pub static Webers: UnitWebersMul = UnitWebersMul;
pub type Quettawebers<T> = Quantity<T, UnitQuettawebers>;
#[allow(non_upper_case_globals)]
pub static Quettawebers: UnitQuettawebersMul = UnitQuettawebersMul;
pub type Ronnawebers<T> = Quantity<T, UnitRonnawebers>;
#[allow(non_upper_case_globals)]
pub static Ronnawebers: UnitRonnawebersMul = UnitRonnawebersMul;
pub type Yottawebers<T> = Quantity<T, UnitYottawebers>;
#[allow(non_upper_case_globals)]
pub static Yottawebers: UnitYottawebersMul = UnitYottawebersMul;
pub type Zettawebers<T> = Quantity<T, UnitZettawebers>;
#[allow(non_upper_case_globals)]
pub static Zettawebers: UnitZettawebersMul = UnitZettawebersMul;
pub type Exawebers<T> = Quantity<T, UnitExawebers>;
#[allow(non_upper_case_globals)]
pub static Exawebers: UnitExawebersMul = UnitExawebersMul;
pub type Petawebers<T> = Quantity<T, UnitPetawebers>;
#[allow(non_upper_case_globals)]
pub static Petawebers: UnitPetawebersMul = UnitPetawebersMul;
pub type Terawebers<T> = Quantity<T, UnitTerawebers>;
#[allow(non_upper_case_globals)]
pub static Terawebers: UnitTerawebersMul = UnitTerawebersMul;
pub type Gigawebers<T> = Quantity<T, UnitGigawebers>;
#[allow(non_upper_case_globals)]
pub static Gigawebers: UnitGigawebersMul = UnitGigawebersMul;
pub type Megawebers<T> = Quantity<T, UnitMegawebers>;
#[allow(non_upper_case_globals)]
pub static Megawebers: UnitMegawebersMul = UnitMegawebersMul;
pub type Kilowebers<T> = Quantity<T, UnitKilowebers>;
#[allow(non_upper_case_globals)]
pub static Kilowebers: UnitKilowebersMul = UnitKilowebersMul;
pub type Hectowebers<T> = Quantity<T, UnitHectowebers>;
#[allow(non_upper_case_globals)]
pub static Hectowebers: UnitHectowebersMul = UnitHectowebersMul;
pub type Decawebers<T> = Quantity<T, UnitDecawebers>;
#[allow(non_upper_case_globals)]
pub static Decawebers: UnitDecawebersMul = UnitDecawebersMul;
pub type Deciwebers<T> = Quantity<T, UnitDeciwebers>;
#[allow(non_upper_case_globals)]
pub static Deciwebers: UnitDeciwebersMul = UnitDeciwebersMul;
pub type Centiwebers<T> = Quantity<T, UnitCentiwebers>;
#[allow(non_upper_case_globals)]
pub static Centiwebers: UnitCentiwebersMul = UnitCentiwebersMul;
pub type Milliwebers<T> = Quantity<T, UnitMilliwebers>;
#[allow(non_upper_case_globals)]
pub static Milliwebers: UnitMilliwebersMul = UnitMilliwebersMul;
pub type Microwebers<T> = Quantity<T, UnitMicrowebers>;
#[allow(non_upper_case_globals)]
pub static Microwebers: UnitMicrowebersMul = UnitMicrowebersMul;
pub type Nanowebers<T> = Quantity<T, UnitNanowebers>;
#[allow(non_upper_case_globals)]
pub static Nanowebers: UnitNanowebersMul = UnitNanowebersMul;
pub type Picowebers<T> = Quantity<T, UnitPicowebers>;
#[allow(non_upper_case_globals)]
pub static Picowebers: UnitPicowebersMul = UnitPicowebersMul;
pub type Femtowebers<T> = Quantity<T, UnitFemtowebers>;
#[allow(non_upper_case_globals)]
pub static Femtowebers: UnitFemtowebersMul = UnitFemtowebersMul;
pub type Attowebers<T> = Quantity<T, UnitAttowebers>;
#[allow(non_upper_case_globals)]
pub static Attowebers: UnitAttowebersMul = UnitAttowebersMul;
pub type Zeptowebers<T> = Quantity<T, UnitZeptowebers>;
#[allow(non_upper_case_globals)]
pub static Zeptowebers: UnitZeptowebersMul = UnitZeptowebersMul;
pub type Yoctowebers<T> = Quantity<T, UnitYoctowebers>;
#[allow(non_upper_case_globals)]
pub static Yoctowebers: UnitYoctowebersMul = UnitYoctowebersMul;
pub type Rontowebers<T> = Quantity<T, UnitRontowebers>;
#[allow(non_upper_case_globals)]
pub static Rontowebers: UnitRontowebersMul = UnitRontowebersMul;
pub type Quectowebers<T> = Quantity<T, UnitQuectowebers>;
#[allow(non_upper_case_globals)]
pub static Quectowebers: UnitQuectowebersMul = UnitQuectowebersMul;
pub struct UnitTeslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeslas {
    #[inline]
    fn clone(&self) -> UnitTeslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeslas {
    #[inline]
    fn eq(&self, other: &UnitTeslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeslas {
    fn default() -> Self {
        UnitTeslas
    }
}
impl Add<UnitTeslas> for UnitTeslas {
    type Output = UnitTeslas;
    #[inline]
    fn add(self, _: UnitTeslas) -> Self::Output {
        UnitTeslas
    }
}
impl AddAssign<UnitTeslas> for UnitTeslas {
    #[inline]
    fn add_assign(&mut self, _: UnitTeslas) {}
}
impl Sub<UnitTeslas> for UnitTeslas {
    type Output = UnitTeslas;
    #[inline]
    fn sub(self, _: UnitTeslas) -> Self::Output {
        UnitTeslas
    }
}
impl SubAssign<UnitTeslas> for UnitTeslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeslas) {}
}
pub struct UnitTeslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeslasMul {
    #[inline]
    fn clone(&self) -> UnitTeslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeslasMul {
    #[inline]
    fn eq(&self, other: &UnitTeslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeslasMul> for i8 {
    type Output = Quantity<i8, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for i16 {
    type Output = Quantity<i16, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for i32 {
    type Output = Quantity<i32, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for i64 {
    type Output = Quantity<i64, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for i128 {
    type Output = Quantity<i128, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for isize {
    type Output = Quantity<isize, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for u8 {
    type Output = Quantity<u8, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for u16 {
    type Output = Quantity<u16, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for u32 {
    type Output = Quantity<u32, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for u64 {
    type Output = Quantity<u64, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for u128 {
    type Output = Quantity<u128, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for usize {
    type Output = Quantity<usize, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for f32 {
    type Output = Quantity<f32, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
impl Mul<UnitTeslasMul> for f64 {
    type Output = Quantity<f64, UnitTeslas>;
    fn mul(self, _: UnitTeslasMul) -> Self::Output {
        Quantity::new(self, UnitTeslas)
    }
}
pub struct UnitQuettateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettateslas {
    #[inline]
    fn clone(&self) -> UnitQuettateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettateslas {
    #[inline]
    fn eq(&self, other: &UnitQuettateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettateslas {
    fn default() -> Self {
        UnitQuettateslas
    }
}
impl Add<UnitQuettateslas> for UnitQuettateslas {
    type Output = UnitQuettateslas;
    #[inline]
    fn add(self, _: UnitQuettateslas) -> Self::Output {
        UnitQuettateslas
    }
}
impl AddAssign<UnitQuettateslas> for UnitQuettateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettateslas) {}
}
impl Sub<UnitQuettateslas> for UnitQuettateslas {
    type Output = UnitQuettateslas;
    #[inline]
    fn sub(self, _: UnitQuettateslas) -> Self::Output {
        UnitQuettateslas
    }
}
impl SubAssign<UnitQuettateslas> for UnitQuettateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettateslas) {}
}
pub struct UnitQuettateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettateslasMul {
    #[inline]
    fn clone(&self) -> UnitQuettateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettateslasMul {
    #[inline]
    fn eq(&self, other: &UnitQuettateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettateslasMul> for i8 {
    type Output = Quantity<i8, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for i16 {
    type Output = Quantity<i16, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for i32 {
    type Output = Quantity<i32, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for i64 {
    type Output = Quantity<i64, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for i128 {
    type Output = Quantity<i128, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for isize {
    type Output = Quantity<isize, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for u8 {
    type Output = Quantity<u8, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for u16 {
    type Output = Quantity<u16, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for u32 {
    type Output = Quantity<u32, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for u64 {
    type Output = Quantity<u64, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for u128 {
    type Output = Quantity<u128, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for usize {
    type Output = Quantity<usize, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for f32 {
    type Output = Quantity<f32, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
impl Mul<UnitQuettateslasMul> for f64 {
    type Output = Quantity<f64, UnitQuettateslas>;
    fn mul(self, _: UnitQuettateslasMul) -> Self::Output {
        Quantity::new(self, UnitQuettateslas)
    }
}
pub struct UnitRonnateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnateslas {
    #[inline]
    fn clone(&self) -> UnitRonnateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnateslas {
    #[inline]
    fn eq(&self, other: &UnitRonnateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnateslas {
    fn default() -> Self {
        UnitRonnateslas
    }
}
impl Add<UnitRonnateslas> for UnitRonnateslas {
    type Output = UnitRonnateslas;
    #[inline]
    fn add(self, _: UnitRonnateslas) -> Self::Output {
        UnitRonnateslas
    }
}
impl AddAssign<UnitRonnateslas> for UnitRonnateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnateslas) {}
}
impl Sub<UnitRonnateslas> for UnitRonnateslas {
    type Output = UnitRonnateslas;
    #[inline]
    fn sub(self, _: UnitRonnateslas) -> Self::Output {
        UnitRonnateslas
    }
}
impl SubAssign<UnitRonnateslas> for UnitRonnateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnateslas) {}
}
pub struct UnitRonnateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnateslasMul {
    #[inline]
    fn clone(&self) -> UnitRonnateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnateslasMul {
    #[inline]
    fn eq(&self, other: &UnitRonnateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnateslasMul> for i8 {
    type Output = Quantity<i8, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for i16 {
    type Output = Quantity<i16, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for i32 {
    type Output = Quantity<i32, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for i64 {
    type Output = Quantity<i64, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for i128 {
    type Output = Quantity<i128, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for isize {
    type Output = Quantity<isize, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for u8 {
    type Output = Quantity<u8, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for u16 {
    type Output = Quantity<u16, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for u32 {
    type Output = Quantity<u32, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for u64 {
    type Output = Quantity<u64, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for u128 {
    type Output = Quantity<u128, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for usize {
    type Output = Quantity<usize, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for f32 {
    type Output = Quantity<f32, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
impl Mul<UnitRonnateslasMul> for f64 {
    type Output = Quantity<f64, UnitRonnateslas>;
    fn mul(self, _: UnitRonnateslasMul) -> Self::Output {
        Quantity::new(self, UnitRonnateslas)
    }
}
pub struct UnitYottateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottateslas {
    #[inline]
    fn clone(&self) -> UnitYottateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottateslas {
    #[inline]
    fn eq(&self, other: &UnitYottateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottateslas {
    fn default() -> Self {
        UnitYottateslas
    }
}
impl Add<UnitYottateslas> for UnitYottateslas {
    type Output = UnitYottateslas;
    #[inline]
    fn add(self, _: UnitYottateslas) -> Self::Output {
        UnitYottateslas
    }
}
impl AddAssign<UnitYottateslas> for UnitYottateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitYottateslas) {}
}
impl Sub<UnitYottateslas> for UnitYottateslas {
    type Output = UnitYottateslas;
    #[inline]
    fn sub(self, _: UnitYottateslas) -> Self::Output {
        UnitYottateslas
    }
}
impl SubAssign<UnitYottateslas> for UnitYottateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottateslas) {}
}
pub struct UnitYottateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottateslasMul {
    #[inline]
    fn clone(&self) -> UnitYottateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottateslasMul {
    #[inline]
    fn eq(&self, other: &UnitYottateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottateslasMul> for i8 {
    type Output = Quantity<i8, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for i16 {
    type Output = Quantity<i16, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for i32 {
    type Output = Quantity<i32, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for i64 {
    type Output = Quantity<i64, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for i128 {
    type Output = Quantity<i128, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for isize {
    type Output = Quantity<isize, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for u8 {
    type Output = Quantity<u8, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for u16 {
    type Output = Quantity<u16, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for u32 {
    type Output = Quantity<u32, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for u64 {
    type Output = Quantity<u64, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for u128 {
    type Output = Quantity<u128, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for usize {
    type Output = Quantity<usize, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for f32 {
    type Output = Quantity<f32, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
impl Mul<UnitYottateslasMul> for f64 {
    type Output = Quantity<f64, UnitYottateslas>;
    fn mul(self, _: UnitYottateslasMul) -> Self::Output {
        Quantity::new(self, UnitYottateslas)
    }
}
pub struct UnitZettateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettateslas {
    #[inline]
    fn clone(&self) -> UnitZettateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettateslas {
    #[inline]
    fn eq(&self, other: &UnitZettateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettateslas {
    fn default() -> Self {
        UnitZettateslas
    }
}
impl Add<UnitZettateslas> for UnitZettateslas {
    type Output = UnitZettateslas;
    #[inline]
    fn add(self, _: UnitZettateslas) -> Self::Output {
        UnitZettateslas
    }
}
impl AddAssign<UnitZettateslas> for UnitZettateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitZettateslas) {}
}
impl Sub<UnitZettateslas> for UnitZettateslas {
    type Output = UnitZettateslas;
    #[inline]
    fn sub(self, _: UnitZettateslas) -> Self::Output {
        UnitZettateslas
    }
}
impl SubAssign<UnitZettateslas> for UnitZettateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettateslas) {}
}
pub struct UnitZettateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettateslasMul {
    #[inline]
    fn clone(&self) -> UnitZettateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettateslasMul {
    #[inline]
    fn eq(&self, other: &UnitZettateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettateslasMul> for i8 {
    type Output = Quantity<i8, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for i16 {
    type Output = Quantity<i16, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for i32 {
    type Output = Quantity<i32, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for i64 {
    type Output = Quantity<i64, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for i128 {
    type Output = Quantity<i128, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for isize {
    type Output = Quantity<isize, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for u8 {
    type Output = Quantity<u8, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for u16 {
    type Output = Quantity<u16, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for u32 {
    type Output = Quantity<u32, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for u64 {
    type Output = Quantity<u64, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for u128 {
    type Output = Quantity<u128, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for usize {
    type Output = Quantity<usize, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for f32 {
    type Output = Quantity<f32, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
impl Mul<UnitZettateslasMul> for f64 {
    type Output = Quantity<f64, UnitZettateslas>;
    fn mul(self, _: UnitZettateslasMul) -> Self::Output {
        Quantity::new(self, UnitZettateslas)
    }
}
pub struct UnitExateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExateslas {
    #[inline]
    fn clone(&self) -> UnitExateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExateslas {
    #[inline]
    fn eq(&self, other: &UnitExateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExateslas {
    fn default() -> Self {
        UnitExateslas
    }
}
impl Add<UnitExateslas> for UnitExateslas {
    type Output = UnitExateslas;
    #[inline]
    fn add(self, _: UnitExateslas) -> Self::Output {
        UnitExateslas
    }
}
impl AddAssign<UnitExateslas> for UnitExateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitExateslas) {}
}
impl Sub<UnitExateslas> for UnitExateslas {
    type Output = UnitExateslas;
    #[inline]
    fn sub(self, _: UnitExateslas) -> Self::Output {
        UnitExateslas
    }
}
impl SubAssign<UnitExateslas> for UnitExateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitExateslas) {}
}
pub struct UnitExateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExateslasMul {
    #[inline]
    fn clone(&self) -> UnitExateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExateslasMul {
    #[inline]
    fn eq(&self, other: &UnitExateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExateslasMul> for i8 {
    type Output = Quantity<i8, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for i16 {
    type Output = Quantity<i16, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for i32 {
    type Output = Quantity<i32, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for i64 {
    type Output = Quantity<i64, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for i128 {
    type Output = Quantity<i128, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for isize {
    type Output = Quantity<isize, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for u8 {
    type Output = Quantity<u8, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for u16 {
    type Output = Quantity<u16, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for u32 {
    type Output = Quantity<u32, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for u64 {
    type Output = Quantity<u64, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for u128 {
    type Output = Quantity<u128, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for usize {
    type Output = Quantity<usize, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for f32 {
    type Output = Quantity<f32, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
impl Mul<UnitExateslasMul> for f64 {
    type Output = Quantity<f64, UnitExateslas>;
    fn mul(self, _: UnitExateslasMul) -> Self::Output {
        Quantity::new(self, UnitExateslas)
    }
}
pub struct UnitPetateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetateslas {
    #[inline]
    fn clone(&self) -> UnitPetateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetateslas {
    #[inline]
    fn eq(&self, other: &UnitPetateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetateslas {
    fn default() -> Self {
        UnitPetateslas
    }
}
impl Add<UnitPetateslas> for UnitPetateslas {
    type Output = UnitPetateslas;
    #[inline]
    fn add(self, _: UnitPetateslas) -> Self::Output {
        UnitPetateslas
    }
}
impl AddAssign<UnitPetateslas> for UnitPetateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitPetateslas) {}
}
impl Sub<UnitPetateslas> for UnitPetateslas {
    type Output = UnitPetateslas;
    #[inline]
    fn sub(self, _: UnitPetateslas) -> Self::Output {
        UnitPetateslas
    }
}
impl SubAssign<UnitPetateslas> for UnitPetateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetateslas) {}
}
pub struct UnitPetateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetateslasMul {
    #[inline]
    fn clone(&self) -> UnitPetateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetateslasMul {
    #[inline]
    fn eq(&self, other: &UnitPetateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetateslasMul> for i8 {
    type Output = Quantity<i8, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for i16 {
    type Output = Quantity<i16, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for i32 {
    type Output = Quantity<i32, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for i64 {
    type Output = Quantity<i64, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for i128 {
    type Output = Quantity<i128, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for isize {
    type Output = Quantity<isize, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for u8 {
    type Output = Quantity<u8, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for u16 {
    type Output = Quantity<u16, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for u32 {
    type Output = Quantity<u32, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for u64 {
    type Output = Quantity<u64, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for u128 {
    type Output = Quantity<u128, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for usize {
    type Output = Quantity<usize, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for f32 {
    type Output = Quantity<f32, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
impl Mul<UnitPetateslasMul> for f64 {
    type Output = Quantity<f64, UnitPetateslas>;
    fn mul(self, _: UnitPetateslasMul) -> Self::Output {
        Quantity::new(self, UnitPetateslas)
    }
}
pub struct UnitTerateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerateslas {
    #[inline]
    fn clone(&self) -> UnitTerateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerateslas {
    #[inline]
    fn eq(&self, other: &UnitTerateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerateslas {
    fn default() -> Self {
        UnitTerateslas
    }
}
impl Add<UnitTerateslas> for UnitTerateslas {
    type Output = UnitTerateslas;
    #[inline]
    fn add(self, _: UnitTerateslas) -> Self::Output {
        UnitTerateslas
    }
}
impl AddAssign<UnitTerateslas> for UnitTerateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitTerateslas) {}
}
impl Sub<UnitTerateslas> for UnitTerateslas {
    type Output = UnitTerateslas;
    #[inline]
    fn sub(self, _: UnitTerateslas) -> Self::Output {
        UnitTerateslas
    }
}
impl SubAssign<UnitTerateslas> for UnitTerateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerateslas) {}
}
pub struct UnitTerateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerateslasMul {
    #[inline]
    fn clone(&self) -> UnitTerateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerateslasMul {
    #[inline]
    fn eq(&self, other: &UnitTerateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerateslasMul> for i8 {
    type Output = Quantity<i8, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for i16 {
    type Output = Quantity<i16, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for i32 {
    type Output = Quantity<i32, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for i64 {
    type Output = Quantity<i64, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for i128 {
    type Output = Quantity<i128, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for isize {
    type Output = Quantity<isize, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for u8 {
    type Output = Quantity<u8, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for u16 {
    type Output = Quantity<u16, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for u32 {
    type Output = Quantity<u32, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for u64 {
    type Output = Quantity<u64, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for u128 {
    type Output = Quantity<u128, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for usize {
    type Output = Quantity<usize, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for f32 {
    type Output = Quantity<f32, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
impl Mul<UnitTerateslasMul> for f64 {
    type Output = Quantity<f64, UnitTerateslas>;
    fn mul(self, _: UnitTerateslasMul) -> Self::Output {
        Quantity::new(self, UnitTerateslas)
    }
}
pub struct UnitGigateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigateslas {
    #[inline]
    fn clone(&self) -> UnitGigateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigateslas {
    #[inline]
    fn eq(&self, other: &UnitGigateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigateslas {
    fn default() -> Self {
        UnitGigateslas
    }
}
impl Add<UnitGigateslas> for UnitGigateslas {
    type Output = UnitGigateslas;
    #[inline]
    fn add(self, _: UnitGigateslas) -> Self::Output {
        UnitGigateslas
    }
}
impl AddAssign<UnitGigateslas> for UnitGigateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitGigateslas) {}
}
impl Sub<UnitGigateslas> for UnitGigateslas {
    type Output = UnitGigateslas;
    #[inline]
    fn sub(self, _: UnitGigateslas) -> Self::Output {
        UnitGigateslas
    }
}
impl SubAssign<UnitGigateslas> for UnitGigateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigateslas) {}
}
pub struct UnitGigateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigateslasMul {
    #[inline]
    fn clone(&self) -> UnitGigateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigateslasMul {
    #[inline]
    fn eq(&self, other: &UnitGigateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigateslasMul> for i8 {
    type Output = Quantity<i8, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for i16 {
    type Output = Quantity<i16, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for i32 {
    type Output = Quantity<i32, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for i64 {
    type Output = Quantity<i64, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for i128 {
    type Output = Quantity<i128, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for isize {
    type Output = Quantity<isize, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for u8 {
    type Output = Quantity<u8, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for u16 {
    type Output = Quantity<u16, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for u32 {
    type Output = Quantity<u32, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for u64 {
    type Output = Quantity<u64, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for u128 {
    type Output = Quantity<u128, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for usize {
    type Output = Quantity<usize, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for f32 {
    type Output = Quantity<f32, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
impl Mul<UnitGigateslasMul> for f64 {
    type Output = Quantity<f64, UnitGigateslas>;
    fn mul(self, _: UnitGigateslasMul) -> Self::Output {
        Quantity::new(self, UnitGigateslas)
    }
}
pub struct UnitMegateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegateslas {
    #[inline]
    fn clone(&self) -> UnitMegateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegateslas {
    #[inline]
    fn eq(&self, other: &UnitMegateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegateslas {
    fn default() -> Self {
        UnitMegateslas
    }
}
impl Add<UnitMegateslas> for UnitMegateslas {
    type Output = UnitMegateslas;
    #[inline]
    fn add(self, _: UnitMegateslas) -> Self::Output {
        UnitMegateslas
    }
}
impl AddAssign<UnitMegateslas> for UnitMegateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitMegateslas) {}
}
impl Sub<UnitMegateslas> for UnitMegateslas {
    type Output = UnitMegateslas;
    #[inline]
    fn sub(self, _: UnitMegateslas) -> Self::Output {
        UnitMegateslas
    }
}
impl SubAssign<UnitMegateslas> for UnitMegateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegateslas) {}
}
pub struct UnitMegateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegateslasMul {
    #[inline]
    fn clone(&self) -> UnitMegateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegateslasMul {
    #[inline]
    fn eq(&self, other: &UnitMegateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegateslasMul> for i8 {
    type Output = Quantity<i8, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for i16 {
    type Output = Quantity<i16, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for i32 {
    type Output = Quantity<i32, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for i64 {
    type Output = Quantity<i64, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for i128 {
    type Output = Quantity<i128, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for isize {
    type Output = Quantity<isize, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for u8 {
    type Output = Quantity<u8, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for u16 {
    type Output = Quantity<u16, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for u32 {
    type Output = Quantity<u32, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for u64 {
    type Output = Quantity<u64, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for u128 {
    type Output = Quantity<u128, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for usize {
    type Output = Quantity<usize, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for f32 {
    type Output = Quantity<f32, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
impl Mul<UnitMegateslasMul> for f64 {
    type Output = Quantity<f64, UnitMegateslas>;
    fn mul(self, _: UnitMegateslasMul) -> Self::Output {
        Quantity::new(self, UnitMegateslas)
    }
}
pub struct UnitKiloteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloteslas {
    #[inline]
    fn clone(&self) -> UnitKiloteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloteslas {
    #[inline]
    fn eq(&self, other: &UnitKiloteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloteslas {
    fn default() -> Self {
        UnitKiloteslas
    }
}
impl Add<UnitKiloteslas> for UnitKiloteslas {
    type Output = UnitKiloteslas;
    #[inline]
    fn add(self, _: UnitKiloteslas) -> Self::Output {
        UnitKiloteslas
    }
}
impl AddAssign<UnitKiloteslas> for UnitKiloteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloteslas) {}
}
impl Sub<UnitKiloteslas> for UnitKiloteslas {
    type Output = UnitKiloteslas;
    #[inline]
    fn sub(self, _: UnitKiloteslas) -> Self::Output {
        UnitKiloteslas
    }
}
impl SubAssign<UnitKiloteslas> for UnitKiloteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloteslas) {}
}
pub struct UnitKiloteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloteslasMul {
    #[inline]
    fn clone(&self) -> UnitKiloteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloteslasMul {
    #[inline]
    fn eq(&self, other: &UnitKiloteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloteslasMul> for i8 {
    type Output = Quantity<i8, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for i16 {
    type Output = Quantity<i16, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for i32 {
    type Output = Quantity<i32, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for i64 {
    type Output = Quantity<i64, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for i128 {
    type Output = Quantity<i128, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for isize {
    type Output = Quantity<isize, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for u8 {
    type Output = Quantity<u8, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for u16 {
    type Output = Quantity<u16, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for u32 {
    type Output = Quantity<u32, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for u64 {
    type Output = Quantity<u64, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for u128 {
    type Output = Quantity<u128, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for usize {
    type Output = Quantity<usize, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for f32 {
    type Output = Quantity<f32, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
impl Mul<UnitKiloteslasMul> for f64 {
    type Output = Quantity<f64, UnitKiloteslas>;
    fn mul(self, _: UnitKiloteslasMul) -> Self::Output {
        Quantity::new(self, UnitKiloteslas)
    }
}
pub struct UnitHectoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoteslas {
    #[inline]
    fn clone(&self) -> UnitHectoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoteslas {
    #[inline]
    fn eq(&self, other: &UnitHectoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoteslas {
    fn default() -> Self {
        UnitHectoteslas
    }
}
impl Add<UnitHectoteslas> for UnitHectoteslas {
    type Output = UnitHectoteslas;
    #[inline]
    fn add(self, _: UnitHectoteslas) -> Self::Output {
        UnitHectoteslas
    }
}
impl AddAssign<UnitHectoteslas> for UnitHectoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoteslas) {}
}
impl Sub<UnitHectoteslas> for UnitHectoteslas {
    type Output = UnitHectoteslas;
    #[inline]
    fn sub(self, _: UnitHectoteslas) -> Self::Output {
        UnitHectoteslas
    }
}
impl SubAssign<UnitHectoteslas> for UnitHectoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoteslas) {}
}
pub struct UnitHectoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoteslasMul {
    #[inline]
    fn clone(&self) -> UnitHectoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitHectoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoteslasMul> for i8 {
    type Output = Quantity<i8, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for i16 {
    type Output = Quantity<i16, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for i32 {
    type Output = Quantity<i32, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for i64 {
    type Output = Quantity<i64, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for i128 {
    type Output = Quantity<i128, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for isize {
    type Output = Quantity<isize, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for u8 {
    type Output = Quantity<u8, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for u16 {
    type Output = Quantity<u16, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for u32 {
    type Output = Quantity<u32, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for u64 {
    type Output = Quantity<u64, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for u128 {
    type Output = Quantity<u128, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for usize {
    type Output = Quantity<usize, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for f32 {
    type Output = Quantity<f32, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
impl Mul<UnitHectoteslasMul> for f64 {
    type Output = Quantity<f64, UnitHectoteslas>;
    fn mul(self, _: UnitHectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitHectoteslas)
    }
}
pub struct UnitDecateslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecateslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecateslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecateslas {
    #[inline]
    fn clone(&self) -> UnitDecateslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecateslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecateslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecateslas {
    #[inline]
    fn eq(&self, other: &UnitDecateslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecateslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecateslas {
    fn default() -> Self {
        UnitDecateslas
    }
}
impl Add<UnitDecateslas> for UnitDecateslas {
    type Output = UnitDecateslas;
    #[inline]
    fn add(self, _: UnitDecateslas) -> Self::Output {
        UnitDecateslas
    }
}
impl AddAssign<UnitDecateslas> for UnitDecateslas {
    #[inline]
    fn add_assign(&mut self, _: UnitDecateslas) {}
}
impl Sub<UnitDecateslas> for UnitDecateslas {
    type Output = UnitDecateslas;
    #[inline]
    fn sub(self, _: UnitDecateslas) -> Self::Output {
        UnitDecateslas
    }
}
impl SubAssign<UnitDecateslas> for UnitDecateslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecateslas) {}
}
pub struct UnitDecateslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecateslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecateslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecateslasMul {
    #[inline]
    fn clone(&self) -> UnitDecateslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecateslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecateslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecateslasMul {
    #[inline]
    fn eq(&self, other: &UnitDecateslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecateslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecateslasMul> for i8 {
    type Output = Quantity<i8, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for i16 {
    type Output = Quantity<i16, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for i32 {
    type Output = Quantity<i32, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for i64 {
    type Output = Quantity<i64, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for i128 {
    type Output = Quantity<i128, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for isize {
    type Output = Quantity<isize, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for u8 {
    type Output = Quantity<u8, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for u16 {
    type Output = Quantity<u16, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for u32 {
    type Output = Quantity<u32, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for u64 {
    type Output = Quantity<u64, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for u128 {
    type Output = Quantity<u128, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for usize {
    type Output = Quantity<usize, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for f32 {
    type Output = Quantity<f32, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
impl Mul<UnitDecateslasMul> for f64 {
    type Output = Quantity<f64, UnitDecateslas>;
    fn mul(self, _: UnitDecateslasMul) -> Self::Output {
        Quantity::new(self, UnitDecateslas)
    }
}
pub struct UnitDeciteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciteslas {
    #[inline]
    fn clone(&self) -> UnitDeciteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciteslas {
    #[inline]
    fn eq(&self, other: &UnitDeciteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciteslas {
    fn default() -> Self {
        UnitDeciteslas
    }
}
impl Add<UnitDeciteslas> for UnitDeciteslas {
    type Output = UnitDeciteslas;
    #[inline]
    fn add(self, _: UnitDeciteslas) -> Self::Output {
        UnitDeciteslas
    }
}
impl AddAssign<UnitDeciteslas> for UnitDeciteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciteslas) {}
}
impl Sub<UnitDeciteslas> for UnitDeciteslas {
    type Output = UnitDeciteslas;
    #[inline]
    fn sub(self, _: UnitDeciteslas) -> Self::Output {
        UnitDeciteslas
    }
}
impl SubAssign<UnitDeciteslas> for UnitDeciteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciteslas) {}
}
pub struct UnitDeciteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciteslasMul {
    #[inline]
    fn clone(&self) -> UnitDeciteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciteslasMul {
    #[inline]
    fn eq(&self, other: &UnitDeciteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciteslasMul> for i8 {
    type Output = Quantity<i8, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for i16 {
    type Output = Quantity<i16, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for i32 {
    type Output = Quantity<i32, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for i64 {
    type Output = Quantity<i64, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for i128 {
    type Output = Quantity<i128, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for isize {
    type Output = Quantity<isize, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for u8 {
    type Output = Quantity<u8, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for u16 {
    type Output = Quantity<u16, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for u32 {
    type Output = Quantity<u32, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for u64 {
    type Output = Quantity<u64, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for u128 {
    type Output = Quantity<u128, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for usize {
    type Output = Quantity<usize, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for f32 {
    type Output = Quantity<f32, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
impl Mul<UnitDeciteslasMul> for f64 {
    type Output = Quantity<f64, UnitDeciteslas>;
    fn mul(self, _: UnitDeciteslasMul) -> Self::Output {
        Quantity::new(self, UnitDeciteslas)
    }
}
pub struct UnitCentiteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiteslas {
    #[inline]
    fn clone(&self) -> UnitCentiteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiteslas {
    #[inline]
    fn eq(&self, other: &UnitCentiteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiteslas {
    fn default() -> Self {
        UnitCentiteslas
    }
}
impl Add<UnitCentiteslas> for UnitCentiteslas {
    type Output = UnitCentiteslas;
    #[inline]
    fn add(self, _: UnitCentiteslas) -> Self::Output {
        UnitCentiteslas
    }
}
impl AddAssign<UnitCentiteslas> for UnitCentiteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiteslas) {}
}
impl Sub<UnitCentiteslas> for UnitCentiteslas {
    type Output = UnitCentiteslas;
    #[inline]
    fn sub(self, _: UnitCentiteslas) -> Self::Output {
        UnitCentiteslas
    }
}
impl SubAssign<UnitCentiteslas> for UnitCentiteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiteslas) {}
}
pub struct UnitCentiteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiteslasMul {
    #[inline]
    fn clone(&self) -> UnitCentiteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiteslasMul {
    #[inline]
    fn eq(&self, other: &UnitCentiteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiteslasMul> for i8 {
    type Output = Quantity<i8, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for i16 {
    type Output = Quantity<i16, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for i32 {
    type Output = Quantity<i32, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for i64 {
    type Output = Quantity<i64, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for i128 {
    type Output = Quantity<i128, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for isize {
    type Output = Quantity<isize, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for u8 {
    type Output = Quantity<u8, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for u16 {
    type Output = Quantity<u16, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for u32 {
    type Output = Quantity<u32, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for u64 {
    type Output = Quantity<u64, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for u128 {
    type Output = Quantity<u128, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for usize {
    type Output = Quantity<usize, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for f32 {
    type Output = Quantity<f32, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
impl Mul<UnitCentiteslasMul> for f64 {
    type Output = Quantity<f64, UnitCentiteslas>;
    fn mul(self, _: UnitCentiteslasMul) -> Self::Output {
        Quantity::new(self, UnitCentiteslas)
    }
}
pub struct UnitMilliteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliteslas {
    #[inline]
    fn clone(&self) -> UnitMilliteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliteslas {
    #[inline]
    fn eq(&self, other: &UnitMilliteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliteslas {
    fn default() -> Self {
        UnitMilliteslas
    }
}
impl Add<UnitMilliteslas> for UnitMilliteslas {
    type Output = UnitMilliteslas;
    #[inline]
    fn add(self, _: UnitMilliteslas) -> Self::Output {
        UnitMilliteslas
    }
}
impl AddAssign<UnitMilliteslas> for UnitMilliteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliteslas) {}
}
impl Sub<UnitMilliteslas> for UnitMilliteslas {
    type Output = UnitMilliteslas;
    #[inline]
    fn sub(self, _: UnitMilliteslas) -> Self::Output {
        UnitMilliteslas
    }
}
impl SubAssign<UnitMilliteslas> for UnitMilliteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliteslas) {}
}
pub struct UnitMilliteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliteslasMul {
    #[inline]
    fn clone(&self) -> UnitMilliteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliteslasMul {
    #[inline]
    fn eq(&self, other: &UnitMilliteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliteslasMul> for i8 {
    type Output = Quantity<i8, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for i16 {
    type Output = Quantity<i16, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for i32 {
    type Output = Quantity<i32, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for i64 {
    type Output = Quantity<i64, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for i128 {
    type Output = Quantity<i128, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for isize {
    type Output = Quantity<isize, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for u8 {
    type Output = Quantity<u8, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for u16 {
    type Output = Quantity<u16, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for u32 {
    type Output = Quantity<u32, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for u64 {
    type Output = Quantity<u64, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for u128 {
    type Output = Quantity<u128, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for usize {
    type Output = Quantity<usize, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for f32 {
    type Output = Quantity<f32, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
impl Mul<UnitMilliteslasMul> for f64 {
    type Output = Quantity<f64, UnitMilliteslas>;
    fn mul(self, _: UnitMilliteslasMul) -> Self::Output {
        Quantity::new(self, UnitMilliteslas)
    }
}
pub struct UnitMicroteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroteslas {
    #[inline]
    fn clone(&self) -> UnitMicroteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroteslas {
    #[inline]
    fn eq(&self, other: &UnitMicroteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroteslas {
    fn default() -> Self {
        UnitMicroteslas
    }
}
impl Add<UnitMicroteslas> for UnitMicroteslas {
    type Output = UnitMicroteslas;
    #[inline]
    fn add(self, _: UnitMicroteslas) -> Self::Output {
        UnitMicroteslas
    }
}
impl AddAssign<UnitMicroteslas> for UnitMicroteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroteslas) {}
}
impl Sub<UnitMicroteslas> for UnitMicroteslas {
    type Output = UnitMicroteslas;
    #[inline]
    fn sub(self, _: UnitMicroteslas) -> Self::Output {
        UnitMicroteslas
    }
}
impl SubAssign<UnitMicroteslas> for UnitMicroteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroteslas) {}
}
pub struct UnitMicroteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroteslasMul {
    #[inline]
    fn clone(&self) -> UnitMicroteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroteslasMul {
    #[inline]
    fn eq(&self, other: &UnitMicroteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroteslasMul> for i8 {
    type Output = Quantity<i8, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for i16 {
    type Output = Quantity<i16, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for i32 {
    type Output = Quantity<i32, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for i64 {
    type Output = Quantity<i64, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for i128 {
    type Output = Quantity<i128, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for isize {
    type Output = Quantity<isize, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for u8 {
    type Output = Quantity<u8, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for u16 {
    type Output = Quantity<u16, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for u32 {
    type Output = Quantity<u32, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for u64 {
    type Output = Quantity<u64, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for u128 {
    type Output = Quantity<u128, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for usize {
    type Output = Quantity<usize, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for f32 {
    type Output = Quantity<f32, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
impl Mul<UnitMicroteslasMul> for f64 {
    type Output = Quantity<f64, UnitMicroteslas>;
    fn mul(self, _: UnitMicroteslasMul) -> Self::Output {
        Quantity::new(self, UnitMicroteslas)
    }
}
pub struct UnitNanoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoteslas {
    #[inline]
    fn clone(&self) -> UnitNanoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoteslas {
    #[inline]
    fn eq(&self, other: &UnitNanoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoteslas {
    fn default() -> Self {
        UnitNanoteslas
    }
}
impl Add<UnitNanoteslas> for UnitNanoteslas {
    type Output = UnitNanoteslas;
    #[inline]
    fn add(self, _: UnitNanoteslas) -> Self::Output {
        UnitNanoteslas
    }
}
impl AddAssign<UnitNanoteslas> for UnitNanoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoteslas) {}
}
impl Sub<UnitNanoteslas> for UnitNanoteslas {
    type Output = UnitNanoteslas;
    #[inline]
    fn sub(self, _: UnitNanoteslas) -> Self::Output {
        UnitNanoteslas
    }
}
impl SubAssign<UnitNanoteslas> for UnitNanoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoteslas) {}
}
pub struct UnitNanoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoteslasMul {
    #[inline]
    fn clone(&self) -> UnitNanoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitNanoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoteslasMul> for i8 {
    type Output = Quantity<i8, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for i16 {
    type Output = Quantity<i16, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for i32 {
    type Output = Quantity<i32, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for i64 {
    type Output = Quantity<i64, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for i128 {
    type Output = Quantity<i128, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for isize {
    type Output = Quantity<isize, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for u8 {
    type Output = Quantity<u8, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for u16 {
    type Output = Quantity<u16, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for u32 {
    type Output = Quantity<u32, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for u64 {
    type Output = Quantity<u64, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for u128 {
    type Output = Quantity<u128, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for usize {
    type Output = Quantity<usize, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for f32 {
    type Output = Quantity<f32, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
impl Mul<UnitNanoteslasMul> for f64 {
    type Output = Quantity<f64, UnitNanoteslas>;
    fn mul(self, _: UnitNanoteslasMul) -> Self::Output {
        Quantity::new(self, UnitNanoteslas)
    }
}
pub struct UnitPicoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoteslas {
    #[inline]
    fn clone(&self) -> UnitPicoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoteslas {
    #[inline]
    fn eq(&self, other: &UnitPicoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoteslas {
    fn default() -> Self {
        UnitPicoteslas
    }
}
impl Add<UnitPicoteslas> for UnitPicoteslas {
    type Output = UnitPicoteslas;
    #[inline]
    fn add(self, _: UnitPicoteslas) -> Self::Output {
        UnitPicoteslas
    }
}
impl AddAssign<UnitPicoteslas> for UnitPicoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoteslas) {}
}
impl Sub<UnitPicoteslas> for UnitPicoteslas {
    type Output = UnitPicoteslas;
    #[inline]
    fn sub(self, _: UnitPicoteslas) -> Self::Output {
        UnitPicoteslas
    }
}
impl SubAssign<UnitPicoteslas> for UnitPicoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoteslas) {}
}
pub struct UnitPicoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoteslasMul {
    #[inline]
    fn clone(&self) -> UnitPicoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitPicoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoteslasMul> for i8 {
    type Output = Quantity<i8, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for i16 {
    type Output = Quantity<i16, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for i32 {
    type Output = Quantity<i32, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for i64 {
    type Output = Quantity<i64, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for i128 {
    type Output = Quantity<i128, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for isize {
    type Output = Quantity<isize, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for u8 {
    type Output = Quantity<u8, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for u16 {
    type Output = Quantity<u16, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for u32 {
    type Output = Quantity<u32, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for u64 {
    type Output = Quantity<u64, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for u128 {
    type Output = Quantity<u128, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for usize {
    type Output = Quantity<usize, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for f32 {
    type Output = Quantity<f32, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
impl Mul<UnitPicoteslasMul> for f64 {
    type Output = Quantity<f64, UnitPicoteslas>;
    fn mul(self, _: UnitPicoteslasMul) -> Self::Output {
        Quantity::new(self, UnitPicoteslas)
    }
}
pub struct UnitFemtoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoteslas {
    #[inline]
    fn clone(&self) -> UnitFemtoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoteslas {
    #[inline]
    fn eq(&self, other: &UnitFemtoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoteslas {
    fn default() -> Self {
        UnitFemtoteslas
    }
}
impl Add<UnitFemtoteslas> for UnitFemtoteslas {
    type Output = UnitFemtoteslas;
    #[inline]
    fn add(self, _: UnitFemtoteslas) -> Self::Output {
        UnitFemtoteslas
    }
}
impl AddAssign<UnitFemtoteslas> for UnitFemtoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoteslas) {}
}
impl Sub<UnitFemtoteslas> for UnitFemtoteslas {
    type Output = UnitFemtoteslas;
    #[inline]
    fn sub(self, _: UnitFemtoteslas) -> Self::Output {
        UnitFemtoteslas
    }
}
impl SubAssign<UnitFemtoteslas> for UnitFemtoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoteslas) {}
}
pub struct UnitFemtoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoteslasMul {
    #[inline]
    fn clone(&self) -> UnitFemtoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoteslasMul> for i8 {
    type Output = Quantity<i8, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for i16 {
    type Output = Quantity<i16, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for i32 {
    type Output = Quantity<i32, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for i64 {
    type Output = Quantity<i64, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for i128 {
    type Output = Quantity<i128, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for isize {
    type Output = Quantity<isize, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for u8 {
    type Output = Quantity<u8, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for u16 {
    type Output = Quantity<u16, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for u32 {
    type Output = Quantity<u32, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for u64 {
    type Output = Quantity<u64, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for u128 {
    type Output = Quantity<u128, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for usize {
    type Output = Quantity<usize, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for f32 {
    type Output = Quantity<f32, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
impl Mul<UnitFemtoteslasMul> for f64 {
    type Output = Quantity<f64, UnitFemtoteslas>;
    fn mul(self, _: UnitFemtoteslasMul) -> Self::Output {
        Quantity::new(self, UnitFemtoteslas)
    }
}
pub struct UnitAttoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoteslas {
    #[inline]
    fn clone(&self) -> UnitAttoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoteslas {
    #[inline]
    fn eq(&self, other: &UnitAttoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoteslas {
    fn default() -> Self {
        UnitAttoteslas
    }
}
impl Add<UnitAttoteslas> for UnitAttoteslas {
    type Output = UnitAttoteslas;
    #[inline]
    fn add(self, _: UnitAttoteslas) -> Self::Output {
        UnitAttoteslas
    }
}
impl AddAssign<UnitAttoteslas> for UnitAttoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoteslas) {}
}
impl Sub<UnitAttoteslas> for UnitAttoteslas {
    type Output = UnitAttoteslas;
    #[inline]
    fn sub(self, _: UnitAttoteslas) -> Self::Output {
        UnitAttoteslas
    }
}
impl SubAssign<UnitAttoteslas> for UnitAttoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoteslas) {}
}
pub struct UnitAttoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoteslasMul {
    #[inline]
    fn clone(&self) -> UnitAttoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitAttoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoteslasMul> for i8 {
    type Output = Quantity<i8, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for i16 {
    type Output = Quantity<i16, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for i32 {
    type Output = Quantity<i32, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for i64 {
    type Output = Quantity<i64, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for i128 {
    type Output = Quantity<i128, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for isize {
    type Output = Quantity<isize, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for u8 {
    type Output = Quantity<u8, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for u16 {
    type Output = Quantity<u16, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for u32 {
    type Output = Quantity<u32, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for u64 {
    type Output = Quantity<u64, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for u128 {
    type Output = Quantity<u128, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for usize {
    type Output = Quantity<usize, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for f32 {
    type Output = Quantity<f32, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
impl Mul<UnitAttoteslasMul> for f64 {
    type Output = Quantity<f64, UnitAttoteslas>;
    fn mul(self, _: UnitAttoteslasMul) -> Self::Output {
        Quantity::new(self, UnitAttoteslas)
    }
}
pub struct UnitZeptoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoteslas {
    #[inline]
    fn clone(&self) -> UnitZeptoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoteslas {
    #[inline]
    fn eq(&self, other: &UnitZeptoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoteslas {
    fn default() -> Self {
        UnitZeptoteslas
    }
}
impl Add<UnitZeptoteslas> for UnitZeptoteslas {
    type Output = UnitZeptoteslas;
    #[inline]
    fn add(self, _: UnitZeptoteslas) -> Self::Output {
        UnitZeptoteslas
    }
}
impl AddAssign<UnitZeptoteslas> for UnitZeptoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoteslas) {}
}
impl Sub<UnitZeptoteslas> for UnitZeptoteslas {
    type Output = UnitZeptoteslas;
    #[inline]
    fn sub(self, _: UnitZeptoteslas) -> Self::Output {
        UnitZeptoteslas
    }
}
impl SubAssign<UnitZeptoteslas> for UnitZeptoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoteslas) {}
}
pub struct UnitZeptoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoteslasMul {
    #[inline]
    fn clone(&self) -> UnitZeptoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoteslasMul> for i8 {
    type Output = Quantity<i8, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for i16 {
    type Output = Quantity<i16, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for i32 {
    type Output = Quantity<i32, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for i64 {
    type Output = Quantity<i64, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for i128 {
    type Output = Quantity<i128, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for isize {
    type Output = Quantity<isize, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for u8 {
    type Output = Quantity<u8, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for u16 {
    type Output = Quantity<u16, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for u32 {
    type Output = Quantity<u32, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for u64 {
    type Output = Quantity<u64, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for u128 {
    type Output = Quantity<u128, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for usize {
    type Output = Quantity<usize, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for f32 {
    type Output = Quantity<f32, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
impl Mul<UnitZeptoteslasMul> for f64 {
    type Output = Quantity<f64, UnitZeptoteslas>;
    fn mul(self, _: UnitZeptoteslasMul) -> Self::Output {
        Quantity::new(self, UnitZeptoteslas)
    }
}
pub struct UnitYoctoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoteslas {
    #[inline]
    fn clone(&self) -> UnitYoctoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoteslas {
    #[inline]
    fn eq(&self, other: &UnitYoctoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoteslas {
    fn default() -> Self {
        UnitYoctoteslas
    }
}
impl Add<UnitYoctoteslas> for UnitYoctoteslas {
    type Output = UnitYoctoteslas;
    #[inline]
    fn add(self, _: UnitYoctoteslas) -> Self::Output {
        UnitYoctoteslas
    }
}
impl AddAssign<UnitYoctoteslas> for UnitYoctoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoteslas) {}
}
impl Sub<UnitYoctoteslas> for UnitYoctoteslas {
    type Output = UnitYoctoteslas;
    #[inline]
    fn sub(self, _: UnitYoctoteslas) -> Self::Output {
        UnitYoctoteslas
    }
}
impl SubAssign<UnitYoctoteslas> for UnitYoctoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoteslas) {}
}
pub struct UnitYoctoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoteslasMul {
    #[inline]
    fn clone(&self) -> UnitYoctoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoteslasMul> for i8 {
    type Output = Quantity<i8, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for i16 {
    type Output = Quantity<i16, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for i32 {
    type Output = Quantity<i32, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for i64 {
    type Output = Quantity<i64, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for i128 {
    type Output = Quantity<i128, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for isize {
    type Output = Quantity<isize, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for u8 {
    type Output = Quantity<u8, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for u16 {
    type Output = Quantity<u16, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for u32 {
    type Output = Quantity<u32, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for u64 {
    type Output = Quantity<u64, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for u128 {
    type Output = Quantity<u128, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for usize {
    type Output = Quantity<usize, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for f32 {
    type Output = Quantity<f32, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
impl Mul<UnitYoctoteslasMul> for f64 {
    type Output = Quantity<f64, UnitYoctoteslas>;
    fn mul(self, _: UnitYoctoteslasMul) -> Self::Output {
        Quantity::new(self, UnitYoctoteslas)
    }
}
pub struct UnitRontoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoteslas {
    #[inline]
    fn clone(&self) -> UnitRontoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoteslas {
    #[inline]
    fn eq(&self, other: &UnitRontoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoteslas {
    fn default() -> Self {
        UnitRontoteslas
    }
}
impl Add<UnitRontoteslas> for UnitRontoteslas {
    type Output = UnitRontoteslas;
    #[inline]
    fn add(self, _: UnitRontoteslas) -> Self::Output {
        UnitRontoteslas
    }
}
impl AddAssign<UnitRontoteslas> for UnitRontoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoteslas) {}
}
impl Sub<UnitRontoteslas> for UnitRontoteslas {
    type Output = UnitRontoteslas;
    #[inline]
    fn sub(self, _: UnitRontoteslas) -> Self::Output {
        UnitRontoteslas
    }
}
impl SubAssign<UnitRontoteslas> for UnitRontoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoteslas) {}
}
pub struct UnitRontoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoteslasMul {
    #[inline]
    fn clone(&self) -> UnitRontoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitRontoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoteslasMul> for i8 {
    type Output = Quantity<i8, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for i16 {
    type Output = Quantity<i16, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for i32 {
    type Output = Quantity<i32, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for i64 {
    type Output = Quantity<i64, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for i128 {
    type Output = Quantity<i128, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for isize {
    type Output = Quantity<isize, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for u8 {
    type Output = Quantity<u8, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for u16 {
    type Output = Quantity<u16, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for u32 {
    type Output = Quantity<u32, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for u64 {
    type Output = Quantity<u64, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for u128 {
    type Output = Quantity<u128, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for usize {
    type Output = Quantity<usize, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for f32 {
    type Output = Quantity<f32, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
impl Mul<UnitRontoteslasMul> for f64 {
    type Output = Quantity<f64, UnitRontoteslas>;
    fn mul(self, _: UnitRontoteslasMul) -> Self::Output {
        Quantity::new(self, UnitRontoteslas)
    }
}
pub struct UnitQuectoteslas;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoteslas {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoteslas")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoteslas {
    #[inline]
    fn clone(&self) -> UnitQuectoteslas {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoteslas {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoteslas {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoteslas {
    #[inline]
    fn eq(&self, other: &UnitQuectoteslas) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoteslas {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoteslas {
    fn default() -> Self {
        UnitQuectoteslas
    }
}
impl Add<UnitQuectoteslas> for UnitQuectoteslas {
    type Output = UnitQuectoteslas;
    #[inline]
    fn add(self, _: UnitQuectoteslas) -> Self::Output {
        UnitQuectoteslas
    }
}
impl AddAssign<UnitQuectoteslas> for UnitQuectoteslas {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoteslas) {}
}
impl Sub<UnitQuectoteslas> for UnitQuectoteslas {
    type Output = UnitQuectoteslas;
    #[inline]
    fn sub(self, _: UnitQuectoteslas) -> Self::Output {
        UnitQuectoteslas
    }
}
impl SubAssign<UnitQuectoteslas> for UnitQuectoteslas {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoteslas) {}
}
pub struct UnitQuectoteslasMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoteslasMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoteslasMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoteslasMul {
    #[inline]
    fn clone(&self) -> UnitQuectoteslasMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoteslasMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoteslasMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoteslasMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoteslasMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoteslasMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoteslasMul> for i8 {
    type Output = Quantity<i8, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for i16 {
    type Output = Quantity<i16, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for i32 {
    type Output = Quantity<i32, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for i64 {
    type Output = Quantity<i64, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for i128 {
    type Output = Quantity<i128, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for isize {
    type Output = Quantity<isize, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for u8 {
    type Output = Quantity<u8, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for u16 {
    type Output = Quantity<u16, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for u32 {
    type Output = Quantity<u32, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for u64 {
    type Output = Quantity<u64, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for u128 {
    type Output = Quantity<u128, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for usize {
    type Output = Quantity<usize, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for f32 {
    type Output = Quantity<f32, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
impl Mul<UnitQuectoteslasMul> for f64 {
    type Output = Quantity<f64, UnitQuectoteslas>;
    fn mul(self, _: UnitQuectoteslasMul) -> Self::Output {
        Quantity::new(self, UnitQuectoteslas)
    }
}
pub type Teslas<T> = Quantity<T, UnitTeslas>;
#[allow(non_upper_case_globals)]
pub static Teslas: UnitTeslasMul = UnitTeslasMul;
pub type Quettateslas<T> = Quantity<T, UnitQuettateslas>;
#[allow(non_upper_case_globals)]
pub static Quettateslas: UnitQuettateslasMul = UnitQuettateslasMul;
pub type Ronnateslas<T> = Quantity<T, UnitRonnateslas>;
#[allow(non_upper_case_globals)]
pub static Ronnateslas: UnitRonnateslasMul = UnitRonnateslasMul;
pub type Yottateslas<T> = Quantity<T, UnitYottateslas>;
#[allow(non_upper_case_globals)]
pub static Yottateslas: UnitYottateslasMul = UnitYottateslasMul;
pub type Zettateslas<T> = Quantity<T, UnitZettateslas>;
#[allow(non_upper_case_globals)]
pub static Zettateslas: UnitZettateslasMul = UnitZettateslasMul;
pub type Exateslas<T> = Quantity<T, UnitExateslas>;
#[allow(non_upper_case_globals)]
pub static Exateslas: UnitExateslasMul = UnitExateslasMul;
pub type Petateslas<T> = Quantity<T, UnitPetateslas>;
#[allow(non_upper_case_globals)]
pub static Petateslas: UnitPetateslasMul = UnitPetateslasMul;
pub type Terateslas<T> = Quantity<T, UnitTerateslas>;
#[allow(non_upper_case_globals)]
pub static Terateslas: UnitTerateslasMul = UnitTerateslasMul;
pub type Gigateslas<T> = Quantity<T, UnitGigateslas>;
#[allow(non_upper_case_globals)]
pub static Gigateslas: UnitGigateslasMul = UnitGigateslasMul;
pub type Megateslas<T> = Quantity<T, UnitMegateslas>;
#[allow(non_upper_case_globals)]
pub static Megateslas: UnitMegateslasMul = UnitMegateslasMul;
pub type Kiloteslas<T> = Quantity<T, UnitKiloteslas>;
#[allow(non_upper_case_globals)]
pub static Kiloteslas: UnitKiloteslasMul = UnitKiloteslasMul;
pub type Hectoteslas<T> = Quantity<T, UnitHectoteslas>;
#[allow(non_upper_case_globals)]
pub static Hectoteslas: UnitHectoteslasMul = UnitHectoteslasMul;
pub type Decateslas<T> = Quantity<T, UnitDecateslas>;
#[allow(non_upper_case_globals)]
pub static Decateslas: UnitDecateslasMul = UnitDecateslasMul;
pub type Deciteslas<T> = Quantity<T, UnitDeciteslas>;
#[allow(non_upper_case_globals)]
pub static Deciteslas: UnitDeciteslasMul = UnitDeciteslasMul;
pub type Centiteslas<T> = Quantity<T, UnitCentiteslas>;
#[allow(non_upper_case_globals)]
pub static Centiteslas: UnitCentiteslasMul = UnitCentiteslasMul;
pub type Milliteslas<T> = Quantity<T, UnitMilliteslas>;
#[allow(non_upper_case_globals)]
pub static Milliteslas: UnitMilliteslasMul = UnitMilliteslasMul;
pub type Microteslas<T> = Quantity<T, UnitMicroteslas>;
#[allow(non_upper_case_globals)]
pub static Microteslas: UnitMicroteslasMul = UnitMicroteslasMul;
pub type Nanoteslas<T> = Quantity<T, UnitNanoteslas>;
#[allow(non_upper_case_globals)]
pub static Nanoteslas: UnitNanoteslasMul = UnitNanoteslasMul;
pub type Picoteslas<T> = Quantity<T, UnitPicoteslas>;
#[allow(non_upper_case_globals)]
pub static Picoteslas: UnitPicoteslasMul = UnitPicoteslasMul;
pub type Femtoteslas<T> = Quantity<T, UnitFemtoteslas>;
#[allow(non_upper_case_globals)]
pub static Femtoteslas: UnitFemtoteslasMul = UnitFemtoteslasMul;
pub type Attoteslas<T> = Quantity<T, UnitAttoteslas>;
#[allow(non_upper_case_globals)]
pub static Attoteslas: UnitAttoteslasMul = UnitAttoteslasMul;
pub type Zeptoteslas<T> = Quantity<T, UnitZeptoteslas>;
#[allow(non_upper_case_globals)]
pub static Zeptoteslas: UnitZeptoteslasMul = UnitZeptoteslasMul;
pub type Yoctoteslas<T> = Quantity<T, UnitYoctoteslas>;
#[allow(non_upper_case_globals)]
pub static Yoctoteslas: UnitYoctoteslasMul = UnitYoctoteslasMul;
pub type Rontoteslas<T> = Quantity<T, UnitRontoteslas>;
#[allow(non_upper_case_globals)]
pub static Rontoteslas: UnitRontoteslasMul = UnitRontoteslasMul;
pub type Quectoteslas<T> = Quantity<T, UnitQuectoteslas>;
#[allow(non_upper_case_globals)]
pub static Quectoteslas: UnitQuectoteslasMul = UnitQuectoteslasMul;
pub struct UnitHenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHenries {
    #[inline]
    fn clone(&self) -> UnitHenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHenries {
    #[inline]
    fn eq(&self, other: &UnitHenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHenries {
    fn default() -> Self {
        UnitHenries
    }
}
impl Add<UnitHenries> for UnitHenries {
    type Output = UnitHenries;
    #[inline]
    fn add(self, _: UnitHenries) -> Self::Output {
        UnitHenries
    }
}
impl AddAssign<UnitHenries> for UnitHenries {
    #[inline]
    fn add_assign(&mut self, _: UnitHenries) {}
}
impl Sub<UnitHenries> for UnitHenries {
    type Output = UnitHenries;
    #[inline]
    fn sub(self, _: UnitHenries) -> Self::Output {
        UnitHenries
    }
}
impl SubAssign<UnitHenries> for UnitHenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitHenries) {}
}
pub struct UnitHenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHenriesMul {
    #[inline]
    fn clone(&self) -> UnitHenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHenriesMul {
    #[inline]
    fn eq(&self, other: &UnitHenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHenriesMul> for i8 {
    type Output = Quantity<i8, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for i16 {
    type Output = Quantity<i16, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for i32 {
    type Output = Quantity<i32, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for i64 {
    type Output = Quantity<i64, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for i128 {
    type Output = Quantity<i128, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for isize {
    type Output = Quantity<isize, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for u8 {
    type Output = Quantity<u8, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for u16 {
    type Output = Quantity<u16, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for u32 {
    type Output = Quantity<u32, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for u64 {
    type Output = Quantity<u64, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for u128 {
    type Output = Quantity<u128, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for usize {
    type Output = Quantity<usize, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for f32 {
    type Output = Quantity<f32, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
impl Mul<UnitHenriesMul> for f64 {
    type Output = Quantity<f64, UnitHenries>;
    fn mul(self, _: UnitHenriesMul) -> Self::Output {
        Quantity::new(self, UnitHenries)
    }
}
pub struct UnitQuettahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahenries {
    #[inline]
    fn clone(&self) -> UnitQuettahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahenries {
    #[inline]
    fn eq(&self, other: &UnitQuettahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettahenries {
    fn default() -> Self {
        UnitQuettahenries
    }
}
impl Add<UnitQuettahenries> for UnitQuettahenries {
    type Output = UnitQuettahenries;
    #[inline]
    fn add(self, _: UnitQuettahenries) -> Self::Output {
        UnitQuettahenries
    }
}
impl AddAssign<UnitQuettahenries> for UnitQuettahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettahenries) {}
}
impl Sub<UnitQuettahenries> for UnitQuettahenries {
    type Output = UnitQuettahenries;
    #[inline]
    fn sub(self, _: UnitQuettahenries) -> Self::Output {
        UnitQuettahenries
    }
}
impl SubAssign<UnitQuettahenries> for UnitQuettahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettahenries) {}
}
pub struct UnitQuettahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahenriesMul {
    #[inline]
    fn clone(&self) -> UnitQuettahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettahenriesMul> for i8 {
    type Output = Quantity<i8, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for i16 {
    type Output = Quantity<i16, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for i32 {
    type Output = Quantity<i32, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for i64 {
    type Output = Quantity<i64, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for i128 {
    type Output = Quantity<i128, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for isize {
    type Output = Quantity<isize, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for u8 {
    type Output = Quantity<u8, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for u16 {
    type Output = Quantity<u16, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for u32 {
    type Output = Quantity<u32, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for u64 {
    type Output = Quantity<u64, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for u128 {
    type Output = Quantity<u128, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for usize {
    type Output = Quantity<usize, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for f32 {
    type Output = Quantity<f32, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
impl Mul<UnitQuettahenriesMul> for f64 {
    type Output = Quantity<f64, UnitQuettahenries>;
    fn mul(self, _: UnitQuettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuettahenries)
    }
}
pub struct UnitRonnahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahenries {
    #[inline]
    fn clone(&self) -> UnitRonnahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahenries {
    #[inline]
    fn eq(&self, other: &UnitRonnahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnahenries {
    fn default() -> Self {
        UnitRonnahenries
    }
}
impl Add<UnitRonnahenries> for UnitRonnahenries {
    type Output = UnitRonnahenries;
    #[inline]
    fn add(self, _: UnitRonnahenries) -> Self::Output {
        UnitRonnahenries
    }
}
impl AddAssign<UnitRonnahenries> for UnitRonnahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnahenries) {}
}
impl Sub<UnitRonnahenries> for UnitRonnahenries {
    type Output = UnitRonnahenries;
    #[inline]
    fn sub(self, _: UnitRonnahenries) -> Self::Output {
        UnitRonnahenries
    }
}
impl SubAssign<UnitRonnahenries> for UnitRonnahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnahenries) {}
}
pub struct UnitRonnahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahenriesMul {
    #[inline]
    fn clone(&self) -> UnitRonnahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnahenriesMul> for i8 {
    type Output = Quantity<i8, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for i16 {
    type Output = Quantity<i16, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for i32 {
    type Output = Quantity<i32, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for i64 {
    type Output = Quantity<i64, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for i128 {
    type Output = Quantity<i128, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for isize {
    type Output = Quantity<isize, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for u8 {
    type Output = Quantity<u8, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for u16 {
    type Output = Quantity<u16, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for u32 {
    type Output = Quantity<u32, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for u64 {
    type Output = Quantity<u64, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for u128 {
    type Output = Quantity<u128, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for usize {
    type Output = Quantity<usize, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for f32 {
    type Output = Quantity<f32, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
impl Mul<UnitRonnahenriesMul> for f64 {
    type Output = Quantity<f64, UnitRonnahenries>;
    fn mul(self, _: UnitRonnahenriesMul) -> Self::Output {
        Quantity::new(self, UnitRonnahenries)
    }
}
pub struct UnitYottahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahenries {
    #[inline]
    fn clone(&self) -> UnitYottahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahenries {
    #[inline]
    fn eq(&self, other: &UnitYottahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottahenries {
    fn default() -> Self {
        UnitYottahenries
    }
}
impl Add<UnitYottahenries> for UnitYottahenries {
    type Output = UnitYottahenries;
    #[inline]
    fn add(self, _: UnitYottahenries) -> Self::Output {
        UnitYottahenries
    }
}
impl AddAssign<UnitYottahenries> for UnitYottahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitYottahenries) {}
}
impl Sub<UnitYottahenries> for UnitYottahenries {
    type Output = UnitYottahenries;
    #[inline]
    fn sub(self, _: UnitYottahenries) -> Self::Output {
        UnitYottahenries
    }
}
impl SubAssign<UnitYottahenries> for UnitYottahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottahenries) {}
}
pub struct UnitYottahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahenriesMul {
    #[inline]
    fn clone(&self) -> UnitYottahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitYottahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottahenriesMul> for i8 {
    type Output = Quantity<i8, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for i16 {
    type Output = Quantity<i16, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for i32 {
    type Output = Quantity<i32, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for i64 {
    type Output = Quantity<i64, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for i128 {
    type Output = Quantity<i128, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for isize {
    type Output = Quantity<isize, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for u8 {
    type Output = Quantity<u8, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for u16 {
    type Output = Quantity<u16, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for u32 {
    type Output = Quantity<u32, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for u64 {
    type Output = Quantity<u64, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for u128 {
    type Output = Quantity<u128, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for usize {
    type Output = Quantity<usize, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for f32 {
    type Output = Quantity<f32, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
impl Mul<UnitYottahenriesMul> for f64 {
    type Output = Quantity<f64, UnitYottahenries>;
    fn mul(self, _: UnitYottahenriesMul) -> Self::Output {
        Quantity::new(self, UnitYottahenries)
    }
}
pub struct UnitZettahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahenries {
    #[inline]
    fn clone(&self) -> UnitZettahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahenries {
    #[inline]
    fn eq(&self, other: &UnitZettahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettahenries {
    fn default() -> Self {
        UnitZettahenries
    }
}
impl Add<UnitZettahenries> for UnitZettahenries {
    type Output = UnitZettahenries;
    #[inline]
    fn add(self, _: UnitZettahenries) -> Self::Output {
        UnitZettahenries
    }
}
impl AddAssign<UnitZettahenries> for UnitZettahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitZettahenries) {}
}
impl Sub<UnitZettahenries> for UnitZettahenries {
    type Output = UnitZettahenries;
    #[inline]
    fn sub(self, _: UnitZettahenries) -> Self::Output {
        UnitZettahenries
    }
}
impl SubAssign<UnitZettahenries> for UnitZettahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettahenries) {}
}
pub struct UnitZettahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahenriesMul {
    #[inline]
    fn clone(&self) -> UnitZettahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitZettahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettahenriesMul> for i8 {
    type Output = Quantity<i8, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for i16 {
    type Output = Quantity<i16, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for i32 {
    type Output = Quantity<i32, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for i64 {
    type Output = Quantity<i64, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for i128 {
    type Output = Quantity<i128, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for isize {
    type Output = Quantity<isize, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for u8 {
    type Output = Quantity<u8, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for u16 {
    type Output = Quantity<u16, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for u32 {
    type Output = Quantity<u32, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for u64 {
    type Output = Quantity<u64, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for u128 {
    type Output = Quantity<u128, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for usize {
    type Output = Quantity<usize, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for f32 {
    type Output = Quantity<f32, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
impl Mul<UnitZettahenriesMul> for f64 {
    type Output = Quantity<f64, UnitZettahenries>;
    fn mul(self, _: UnitZettahenriesMul) -> Self::Output {
        Quantity::new(self, UnitZettahenries)
    }
}
pub struct UnitExahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahenries {
    #[inline]
    fn clone(&self) -> UnitExahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahenries {
    #[inline]
    fn eq(&self, other: &UnitExahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExahenries {
    fn default() -> Self {
        UnitExahenries
    }
}
impl Add<UnitExahenries> for UnitExahenries {
    type Output = UnitExahenries;
    #[inline]
    fn add(self, _: UnitExahenries) -> Self::Output {
        UnitExahenries
    }
}
impl AddAssign<UnitExahenries> for UnitExahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitExahenries) {}
}
impl Sub<UnitExahenries> for UnitExahenries {
    type Output = UnitExahenries;
    #[inline]
    fn sub(self, _: UnitExahenries) -> Self::Output {
        UnitExahenries
    }
}
impl SubAssign<UnitExahenries> for UnitExahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitExahenries) {}
}
pub struct UnitExahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahenriesMul {
    #[inline]
    fn clone(&self) -> UnitExahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitExahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExahenriesMul> for i8 {
    type Output = Quantity<i8, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for i16 {
    type Output = Quantity<i16, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for i32 {
    type Output = Quantity<i32, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for i64 {
    type Output = Quantity<i64, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for i128 {
    type Output = Quantity<i128, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for isize {
    type Output = Quantity<isize, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for u8 {
    type Output = Quantity<u8, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for u16 {
    type Output = Quantity<u16, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for u32 {
    type Output = Quantity<u32, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for u64 {
    type Output = Quantity<u64, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for u128 {
    type Output = Quantity<u128, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for usize {
    type Output = Quantity<usize, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for f32 {
    type Output = Quantity<f32, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
impl Mul<UnitExahenriesMul> for f64 {
    type Output = Quantity<f64, UnitExahenries>;
    fn mul(self, _: UnitExahenriesMul) -> Self::Output {
        Quantity::new(self, UnitExahenries)
    }
}
pub struct UnitPetahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahenries {
    #[inline]
    fn clone(&self) -> UnitPetahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahenries {
    #[inline]
    fn eq(&self, other: &UnitPetahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetahenries {
    fn default() -> Self {
        UnitPetahenries
    }
}
impl Add<UnitPetahenries> for UnitPetahenries {
    type Output = UnitPetahenries;
    #[inline]
    fn add(self, _: UnitPetahenries) -> Self::Output {
        UnitPetahenries
    }
}
impl AddAssign<UnitPetahenries> for UnitPetahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitPetahenries) {}
}
impl Sub<UnitPetahenries> for UnitPetahenries {
    type Output = UnitPetahenries;
    #[inline]
    fn sub(self, _: UnitPetahenries) -> Self::Output {
        UnitPetahenries
    }
}
impl SubAssign<UnitPetahenries> for UnitPetahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetahenries) {}
}
pub struct UnitPetahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahenriesMul {
    #[inline]
    fn clone(&self) -> UnitPetahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitPetahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetahenriesMul> for i8 {
    type Output = Quantity<i8, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for i16 {
    type Output = Quantity<i16, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for i32 {
    type Output = Quantity<i32, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for i64 {
    type Output = Quantity<i64, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for i128 {
    type Output = Quantity<i128, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for isize {
    type Output = Quantity<isize, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for u8 {
    type Output = Quantity<u8, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for u16 {
    type Output = Quantity<u16, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for u32 {
    type Output = Quantity<u32, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for u64 {
    type Output = Quantity<u64, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for u128 {
    type Output = Quantity<u128, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for usize {
    type Output = Quantity<usize, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for f32 {
    type Output = Quantity<f32, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
impl Mul<UnitPetahenriesMul> for f64 {
    type Output = Quantity<f64, UnitPetahenries>;
    fn mul(self, _: UnitPetahenriesMul) -> Self::Output {
        Quantity::new(self, UnitPetahenries)
    }
}
pub struct UnitTerahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahenries {
    #[inline]
    fn clone(&self) -> UnitTerahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahenries {
    #[inline]
    fn eq(&self, other: &UnitTerahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerahenries {
    fn default() -> Self {
        UnitTerahenries
    }
}
impl Add<UnitTerahenries> for UnitTerahenries {
    type Output = UnitTerahenries;
    #[inline]
    fn add(self, _: UnitTerahenries) -> Self::Output {
        UnitTerahenries
    }
}
impl AddAssign<UnitTerahenries> for UnitTerahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitTerahenries) {}
}
impl Sub<UnitTerahenries> for UnitTerahenries {
    type Output = UnitTerahenries;
    #[inline]
    fn sub(self, _: UnitTerahenries) -> Self::Output {
        UnitTerahenries
    }
}
impl SubAssign<UnitTerahenries> for UnitTerahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerahenries) {}
}
pub struct UnitTerahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahenriesMul {
    #[inline]
    fn clone(&self) -> UnitTerahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitTerahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerahenriesMul> for i8 {
    type Output = Quantity<i8, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for i16 {
    type Output = Quantity<i16, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for i32 {
    type Output = Quantity<i32, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for i64 {
    type Output = Quantity<i64, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for i128 {
    type Output = Quantity<i128, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for isize {
    type Output = Quantity<isize, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for u8 {
    type Output = Quantity<u8, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for u16 {
    type Output = Quantity<u16, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for u32 {
    type Output = Quantity<u32, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for u64 {
    type Output = Quantity<u64, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for u128 {
    type Output = Quantity<u128, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for usize {
    type Output = Quantity<usize, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for f32 {
    type Output = Quantity<f32, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
impl Mul<UnitTerahenriesMul> for f64 {
    type Output = Quantity<f64, UnitTerahenries>;
    fn mul(self, _: UnitTerahenriesMul) -> Self::Output {
        Quantity::new(self, UnitTerahenries)
    }
}
pub struct UnitGigahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahenries {
    #[inline]
    fn clone(&self) -> UnitGigahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahenries {
    #[inline]
    fn eq(&self, other: &UnitGigahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigahenries {
    fn default() -> Self {
        UnitGigahenries
    }
}
impl Add<UnitGigahenries> for UnitGigahenries {
    type Output = UnitGigahenries;
    #[inline]
    fn add(self, _: UnitGigahenries) -> Self::Output {
        UnitGigahenries
    }
}
impl AddAssign<UnitGigahenries> for UnitGigahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitGigahenries) {}
}
impl Sub<UnitGigahenries> for UnitGigahenries {
    type Output = UnitGigahenries;
    #[inline]
    fn sub(self, _: UnitGigahenries) -> Self::Output {
        UnitGigahenries
    }
}
impl SubAssign<UnitGigahenries> for UnitGigahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigahenries) {}
}
pub struct UnitGigahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahenriesMul {
    #[inline]
    fn clone(&self) -> UnitGigahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitGigahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigahenriesMul> for i8 {
    type Output = Quantity<i8, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for i16 {
    type Output = Quantity<i16, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for i32 {
    type Output = Quantity<i32, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for i64 {
    type Output = Quantity<i64, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for i128 {
    type Output = Quantity<i128, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for isize {
    type Output = Quantity<isize, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for u8 {
    type Output = Quantity<u8, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for u16 {
    type Output = Quantity<u16, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for u32 {
    type Output = Quantity<u32, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for u64 {
    type Output = Quantity<u64, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for u128 {
    type Output = Quantity<u128, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for usize {
    type Output = Quantity<usize, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for f32 {
    type Output = Quantity<f32, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
impl Mul<UnitGigahenriesMul> for f64 {
    type Output = Quantity<f64, UnitGigahenries>;
    fn mul(self, _: UnitGigahenriesMul) -> Self::Output {
        Quantity::new(self, UnitGigahenries)
    }
}
pub struct UnitMegahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahenries {
    #[inline]
    fn clone(&self) -> UnitMegahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahenries {
    #[inline]
    fn eq(&self, other: &UnitMegahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegahenries {
    fn default() -> Self {
        UnitMegahenries
    }
}
impl Add<UnitMegahenries> for UnitMegahenries {
    type Output = UnitMegahenries;
    #[inline]
    fn add(self, _: UnitMegahenries) -> Self::Output {
        UnitMegahenries
    }
}
impl AddAssign<UnitMegahenries> for UnitMegahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitMegahenries) {}
}
impl Sub<UnitMegahenries> for UnitMegahenries {
    type Output = UnitMegahenries;
    #[inline]
    fn sub(self, _: UnitMegahenries) -> Self::Output {
        UnitMegahenries
    }
}
impl SubAssign<UnitMegahenries> for UnitMegahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegahenries) {}
}
pub struct UnitMegahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahenriesMul {
    #[inline]
    fn clone(&self) -> UnitMegahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitMegahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegahenriesMul> for i8 {
    type Output = Quantity<i8, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for i16 {
    type Output = Quantity<i16, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for i32 {
    type Output = Quantity<i32, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for i64 {
    type Output = Quantity<i64, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for i128 {
    type Output = Quantity<i128, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for isize {
    type Output = Quantity<isize, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for u8 {
    type Output = Quantity<u8, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for u16 {
    type Output = Quantity<u16, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for u32 {
    type Output = Quantity<u32, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for u64 {
    type Output = Quantity<u64, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for u128 {
    type Output = Quantity<u128, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for usize {
    type Output = Quantity<usize, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for f32 {
    type Output = Quantity<f32, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
impl Mul<UnitMegahenriesMul> for f64 {
    type Output = Quantity<f64, UnitMegahenries>;
    fn mul(self, _: UnitMegahenriesMul) -> Self::Output {
        Quantity::new(self, UnitMegahenries)
    }
}
pub struct UnitKilohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohenries {
    #[inline]
    fn clone(&self) -> UnitKilohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohenries {
    #[inline]
    fn eq(&self, other: &UnitKilohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilohenries {
    fn default() -> Self {
        UnitKilohenries
    }
}
impl Add<UnitKilohenries> for UnitKilohenries {
    type Output = UnitKilohenries;
    #[inline]
    fn add(self, _: UnitKilohenries) -> Self::Output {
        UnitKilohenries
    }
}
impl AddAssign<UnitKilohenries> for UnitKilohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitKilohenries) {}
}
impl Sub<UnitKilohenries> for UnitKilohenries {
    type Output = UnitKilohenries;
    #[inline]
    fn sub(self, _: UnitKilohenries) -> Self::Output {
        UnitKilohenries
    }
}
impl SubAssign<UnitKilohenries> for UnitKilohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilohenries) {}
}
pub struct UnitKilohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohenriesMul {
    #[inline]
    fn clone(&self) -> UnitKilohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitKilohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilohenriesMul> for i8 {
    type Output = Quantity<i8, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for i16 {
    type Output = Quantity<i16, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for i32 {
    type Output = Quantity<i32, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for i64 {
    type Output = Quantity<i64, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for i128 {
    type Output = Quantity<i128, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for isize {
    type Output = Quantity<isize, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for u8 {
    type Output = Quantity<u8, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for u16 {
    type Output = Quantity<u16, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for u32 {
    type Output = Quantity<u32, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for u64 {
    type Output = Quantity<u64, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for u128 {
    type Output = Quantity<u128, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for usize {
    type Output = Quantity<usize, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for f32 {
    type Output = Quantity<f32, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
impl Mul<UnitKilohenriesMul> for f64 {
    type Output = Quantity<f64, UnitKilohenries>;
    fn mul(self, _: UnitKilohenriesMul) -> Self::Output {
        Quantity::new(self, UnitKilohenries)
    }
}
pub struct UnitHectohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohenries {
    #[inline]
    fn clone(&self) -> UnitHectohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohenries {
    #[inline]
    fn eq(&self, other: &UnitHectohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectohenries {
    fn default() -> Self {
        UnitHectohenries
    }
}
impl Add<UnitHectohenries> for UnitHectohenries {
    type Output = UnitHectohenries;
    #[inline]
    fn add(self, _: UnitHectohenries) -> Self::Output {
        UnitHectohenries
    }
}
impl AddAssign<UnitHectohenries> for UnitHectohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitHectohenries) {}
}
impl Sub<UnitHectohenries> for UnitHectohenries {
    type Output = UnitHectohenries;
    #[inline]
    fn sub(self, _: UnitHectohenries) -> Self::Output {
        UnitHectohenries
    }
}
impl SubAssign<UnitHectohenries> for UnitHectohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectohenries) {}
}
pub struct UnitHectohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohenriesMul {
    #[inline]
    fn clone(&self) -> UnitHectohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitHectohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectohenriesMul> for i8 {
    type Output = Quantity<i8, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for i16 {
    type Output = Quantity<i16, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for i32 {
    type Output = Quantity<i32, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for i64 {
    type Output = Quantity<i64, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for i128 {
    type Output = Quantity<i128, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for isize {
    type Output = Quantity<isize, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for u8 {
    type Output = Quantity<u8, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for u16 {
    type Output = Quantity<u16, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for u32 {
    type Output = Quantity<u32, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for u64 {
    type Output = Quantity<u64, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for u128 {
    type Output = Quantity<u128, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for usize {
    type Output = Quantity<usize, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for f32 {
    type Output = Quantity<f32, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
impl Mul<UnitHectohenriesMul> for f64 {
    type Output = Quantity<f64, UnitHectohenries>;
    fn mul(self, _: UnitHectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitHectohenries)
    }
}
pub struct UnitDecahenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahenries {
    #[inline]
    fn clone(&self) -> UnitDecahenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahenries {
    #[inline]
    fn eq(&self, other: &UnitDecahenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecahenries {
    fn default() -> Self {
        UnitDecahenries
    }
}
impl Add<UnitDecahenries> for UnitDecahenries {
    type Output = UnitDecahenries;
    #[inline]
    fn add(self, _: UnitDecahenries) -> Self::Output {
        UnitDecahenries
    }
}
impl AddAssign<UnitDecahenries> for UnitDecahenries {
    #[inline]
    fn add_assign(&mut self, _: UnitDecahenries) {}
}
impl Sub<UnitDecahenries> for UnitDecahenries {
    type Output = UnitDecahenries;
    #[inline]
    fn sub(self, _: UnitDecahenries) -> Self::Output {
        UnitDecahenries
    }
}
impl SubAssign<UnitDecahenries> for UnitDecahenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecahenries) {}
}
pub struct UnitDecahenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahenriesMul {
    #[inline]
    fn clone(&self) -> UnitDecahenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahenriesMul {
    #[inline]
    fn eq(&self, other: &UnitDecahenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecahenriesMul> for i8 {
    type Output = Quantity<i8, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for i16 {
    type Output = Quantity<i16, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for i32 {
    type Output = Quantity<i32, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for i64 {
    type Output = Quantity<i64, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for i128 {
    type Output = Quantity<i128, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for isize {
    type Output = Quantity<isize, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for u8 {
    type Output = Quantity<u8, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for u16 {
    type Output = Quantity<u16, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for u32 {
    type Output = Quantity<u32, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for u64 {
    type Output = Quantity<u64, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for u128 {
    type Output = Quantity<u128, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for usize {
    type Output = Quantity<usize, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for f32 {
    type Output = Quantity<f32, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
impl Mul<UnitDecahenriesMul> for f64 {
    type Output = Quantity<f64, UnitDecahenries>;
    fn mul(self, _: UnitDecahenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecahenries)
    }
}
pub struct UnitDecihenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihenries {
    #[inline]
    fn clone(&self) -> UnitDecihenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihenries {
    #[inline]
    fn eq(&self, other: &UnitDecihenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecihenries {
    fn default() -> Self {
        UnitDecihenries
    }
}
impl Add<UnitDecihenries> for UnitDecihenries {
    type Output = UnitDecihenries;
    #[inline]
    fn add(self, _: UnitDecihenries) -> Self::Output {
        UnitDecihenries
    }
}
impl AddAssign<UnitDecihenries> for UnitDecihenries {
    #[inline]
    fn add_assign(&mut self, _: UnitDecihenries) {}
}
impl Sub<UnitDecihenries> for UnitDecihenries {
    type Output = UnitDecihenries;
    #[inline]
    fn sub(self, _: UnitDecihenries) -> Self::Output {
        UnitDecihenries
    }
}
impl SubAssign<UnitDecihenries> for UnitDecihenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecihenries) {}
}
pub struct UnitDecihenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihenriesMul {
    #[inline]
    fn clone(&self) -> UnitDecihenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihenriesMul {
    #[inline]
    fn eq(&self, other: &UnitDecihenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecihenriesMul> for i8 {
    type Output = Quantity<i8, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for i16 {
    type Output = Quantity<i16, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for i32 {
    type Output = Quantity<i32, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for i64 {
    type Output = Quantity<i64, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for i128 {
    type Output = Quantity<i128, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for isize {
    type Output = Quantity<isize, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for u8 {
    type Output = Quantity<u8, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for u16 {
    type Output = Quantity<u16, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for u32 {
    type Output = Quantity<u32, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for u64 {
    type Output = Quantity<u64, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for u128 {
    type Output = Quantity<u128, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for usize {
    type Output = Quantity<usize, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for f32 {
    type Output = Quantity<f32, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
impl Mul<UnitDecihenriesMul> for f64 {
    type Output = Quantity<f64, UnitDecihenries>;
    fn mul(self, _: UnitDecihenriesMul) -> Self::Output {
        Quantity::new(self, UnitDecihenries)
    }
}
pub struct UnitCentihenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihenries {
    #[inline]
    fn clone(&self) -> UnitCentihenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihenries {
    #[inline]
    fn eq(&self, other: &UnitCentihenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentihenries {
    fn default() -> Self {
        UnitCentihenries
    }
}
impl Add<UnitCentihenries> for UnitCentihenries {
    type Output = UnitCentihenries;
    #[inline]
    fn add(self, _: UnitCentihenries) -> Self::Output {
        UnitCentihenries
    }
}
impl AddAssign<UnitCentihenries> for UnitCentihenries {
    #[inline]
    fn add_assign(&mut self, _: UnitCentihenries) {}
}
impl Sub<UnitCentihenries> for UnitCentihenries {
    type Output = UnitCentihenries;
    #[inline]
    fn sub(self, _: UnitCentihenries) -> Self::Output {
        UnitCentihenries
    }
}
impl SubAssign<UnitCentihenries> for UnitCentihenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentihenries) {}
}
pub struct UnitCentihenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihenriesMul {
    #[inline]
    fn clone(&self) -> UnitCentihenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihenriesMul {
    #[inline]
    fn eq(&self, other: &UnitCentihenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentihenriesMul> for i8 {
    type Output = Quantity<i8, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for i16 {
    type Output = Quantity<i16, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for i32 {
    type Output = Quantity<i32, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for i64 {
    type Output = Quantity<i64, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for i128 {
    type Output = Quantity<i128, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for isize {
    type Output = Quantity<isize, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for u8 {
    type Output = Quantity<u8, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for u16 {
    type Output = Quantity<u16, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for u32 {
    type Output = Quantity<u32, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for u64 {
    type Output = Quantity<u64, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for u128 {
    type Output = Quantity<u128, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for usize {
    type Output = Quantity<usize, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for f32 {
    type Output = Quantity<f32, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
impl Mul<UnitCentihenriesMul> for f64 {
    type Output = Quantity<f64, UnitCentihenries>;
    fn mul(self, _: UnitCentihenriesMul) -> Self::Output {
        Quantity::new(self, UnitCentihenries)
    }
}
pub struct UnitMillihenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihenries {
    #[inline]
    fn clone(&self) -> UnitMillihenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihenries {
    #[inline]
    fn eq(&self, other: &UnitMillihenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillihenries {
    fn default() -> Self {
        UnitMillihenries
    }
}
impl Add<UnitMillihenries> for UnitMillihenries {
    type Output = UnitMillihenries;
    #[inline]
    fn add(self, _: UnitMillihenries) -> Self::Output {
        UnitMillihenries
    }
}
impl AddAssign<UnitMillihenries> for UnitMillihenries {
    #[inline]
    fn add_assign(&mut self, _: UnitMillihenries) {}
}
impl Sub<UnitMillihenries> for UnitMillihenries {
    type Output = UnitMillihenries;
    #[inline]
    fn sub(self, _: UnitMillihenries) -> Self::Output {
        UnitMillihenries
    }
}
impl SubAssign<UnitMillihenries> for UnitMillihenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillihenries) {}
}
pub struct UnitMillihenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihenriesMul {
    #[inline]
    fn clone(&self) -> UnitMillihenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihenriesMul {
    #[inline]
    fn eq(&self, other: &UnitMillihenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillihenriesMul> for i8 {
    type Output = Quantity<i8, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for i16 {
    type Output = Quantity<i16, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for i32 {
    type Output = Quantity<i32, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for i64 {
    type Output = Quantity<i64, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for i128 {
    type Output = Quantity<i128, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for isize {
    type Output = Quantity<isize, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for u8 {
    type Output = Quantity<u8, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for u16 {
    type Output = Quantity<u16, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for u32 {
    type Output = Quantity<u32, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for u64 {
    type Output = Quantity<u64, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for u128 {
    type Output = Quantity<u128, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for usize {
    type Output = Quantity<usize, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for f32 {
    type Output = Quantity<f32, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
impl Mul<UnitMillihenriesMul> for f64 {
    type Output = Quantity<f64, UnitMillihenries>;
    fn mul(self, _: UnitMillihenriesMul) -> Self::Output {
        Quantity::new(self, UnitMillihenries)
    }
}
pub struct UnitMicrohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohenries {
    #[inline]
    fn clone(&self) -> UnitMicrohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohenries {
    #[inline]
    fn eq(&self, other: &UnitMicrohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrohenries {
    fn default() -> Self {
        UnitMicrohenries
    }
}
impl Add<UnitMicrohenries> for UnitMicrohenries {
    type Output = UnitMicrohenries;
    #[inline]
    fn add(self, _: UnitMicrohenries) -> Self::Output {
        UnitMicrohenries
    }
}
impl AddAssign<UnitMicrohenries> for UnitMicrohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrohenries) {}
}
impl Sub<UnitMicrohenries> for UnitMicrohenries {
    type Output = UnitMicrohenries;
    #[inline]
    fn sub(self, _: UnitMicrohenries) -> Self::Output {
        UnitMicrohenries
    }
}
impl SubAssign<UnitMicrohenries> for UnitMicrohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrohenries) {}
}
pub struct UnitMicrohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohenriesMul {
    #[inline]
    fn clone(&self) -> UnitMicrohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitMicrohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrohenriesMul> for i8 {
    type Output = Quantity<i8, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for i16 {
    type Output = Quantity<i16, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for i32 {
    type Output = Quantity<i32, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for i64 {
    type Output = Quantity<i64, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for i128 {
    type Output = Quantity<i128, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for isize {
    type Output = Quantity<isize, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for u8 {
    type Output = Quantity<u8, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for u16 {
    type Output = Quantity<u16, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for u32 {
    type Output = Quantity<u32, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for u64 {
    type Output = Quantity<u64, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for u128 {
    type Output = Quantity<u128, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for usize {
    type Output = Quantity<usize, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for f32 {
    type Output = Quantity<f32, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
impl Mul<UnitMicrohenriesMul> for f64 {
    type Output = Quantity<f64, UnitMicrohenries>;
    fn mul(self, _: UnitMicrohenriesMul) -> Self::Output {
        Quantity::new(self, UnitMicrohenries)
    }
}
pub struct UnitNanohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohenries {
    #[inline]
    fn clone(&self) -> UnitNanohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohenries {
    #[inline]
    fn eq(&self, other: &UnitNanohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanohenries {
    fn default() -> Self {
        UnitNanohenries
    }
}
impl Add<UnitNanohenries> for UnitNanohenries {
    type Output = UnitNanohenries;
    #[inline]
    fn add(self, _: UnitNanohenries) -> Self::Output {
        UnitNanohenries
    }
}
impl AddAssign<UnitNanohenries> for UnitNanohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitNanohenries) {}
}
impl Sub<UnitNanohenries> for UnitNanohenries {
    type Output = UnitNanohenries;
    #[inline]
    fn sub(self, _: UnitNanohenries) -> Self::Output {
        UnitNanohenries
    }
}
impl SubAssign<UnitNanohenries> for UnitNanohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanohenries) {}
}
pub struct UnitNanohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohenriesMul {
    #[inline]
    fn clone(&self) -> UnitNanohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitNanohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanohenriesMul> for i8 {
    type Output = Quantity<i8, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for i16 {
    type Output = Quantity<i16, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for i32 {
    type Output = Quantity<i32, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for i64 {
    type Output = Quantity<i64, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for i128 {
    type Output = Quantity<i128, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for isize {
    type Output = Quantity<isize, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for u8 {
    type Output = Quantity<u8, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for u16 {
    type Output = Quantity<u16, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for u32 {
    type Output = Quantity<u32, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for u64 {
    type Output = Quantity<u64, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for u128 {
    type Output = Quantity<u128, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for usize {
    type Output = Quantity<usize, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for f32 {
    type Output = Quantity<f32, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
impl Mul<UnitNanohenriesMul> for f64 {
    type Output = Quantity<f64, UnitNanohenries>;
    fn mul(self, _: UnitNanohenriesMul) -> Self::Output {
        Quantity::new(self, UnitNanohenries)
    }
}
pub struct UnitPicohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohenries {
    #[inline]
    fn clone(&self) -> UnitPicohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohenries {
    #[inline]
    fn eq(&self, other: &UnitPicohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicohenries {
    fn default() -> Self {
        UnitPicohenries
    }
}
impl Add<UnitPicohenries> for UnitPicohenries {
    type Output = UnitPicohenries;
    #[inline]
    fn add(self, _: UnitPicohenries) -> Self::Output {
        UnitPicohenries
    }
}
impl AddAssign<UnitPicohenries> for UnitPicohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitPicohenries) {}
}
impl Sub<UnitPicohenries> for UnitPicohenries {
    type Output = UnitPicohenries;
    #[inline]
    fn sub(self, _: UnitPicohenries) -> Self::Output {
        UnitPicohenries
    }
}
impl SubAssign<UnitPicohenries> for UnitPicohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicohenries) {}
}
pub struct UnitPicohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohenriesMul {
    #[inline]
    fn clone(&self) -> UnitPicohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitPicohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicohenriesMul> for i8 {
    type Output = Quantity<i8, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for i16 {
    type Output = Quantity<i16, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for i32 {
    type Output = Quantity<i32, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for i64 {
    type Output = Quantity<i64, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for i128 {
    type Output = Quantity<i128, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for isize {
    type Output = Quantity<isize, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for u8 {
    type Output = Quantity<u8, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for u16 {
    type Output = Quantity<u16, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for u32 {
    type Output = Quantity<u32, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for u64 {
    type Output = Quantity<u64, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for u128 {
    type Output = Quantity<u128, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for usize {
    type Output = Quantity<usize, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for f32 {
    type Output = Quantity<f32, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
impl Mul<UnitPicohenriesMul> for f64 {
    type Output = Quantity<f64, UnitPicohenries>;
    fn mul(self, _: UnitPicohenriesMul) -> Self::Output {
        Quantity::new(self, UnitPicohenries)
    }
}
pub struct UnitFemtohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohenries {
    #[inline]
    fn clone(&self) -> UnitFemtohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohenries {
    #[inline]
    fn eq(&self, other: &UnitFemtohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtohenries {
    fn default() -> Self {
        UnitFemtohenries
    }
}
impl Add<UnitFemtohenries> for UnitFemtohenries {
    type Output = UnitFemtohenries;
    #[inline]
    fn add(self, _: UnitFemtohenries) -> Self::Output {
        UnitFemtohenries
    }
}
impl AddAssign<UnitFemtohenries> for UnitFemtohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtohenries) {}
}
impl Sub<UnitFemtohenries> for UnitFemtohenries {
    type Output = UnitFemtohenries;
    #[inline]
    fn sub(self, _: UnitFemtohenries) -> Self::Output {
        UnitFemtohenries
    }
}
impl SubAssign<UnitFemtohenries> for UnitFemtohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtohenries) {}
}
pub struct UnitFemtohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohenriesMul {
    #[inline]
    fn clone(&self) -> UnitFemtohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtohenriesMul> for i8 {
    type Output = Quantity<i8, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for i16 {
    type Output = Quantity<i16, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for i32 {
    type Output = Quantity<i32, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for i64 {
    type Output = Quantity<i64, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for i128 {
    type Output = Quantity<i128, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for isize {
    type Output = Quantity<isize, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for u8 {
    type Output = Quantity<u8, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for u16 {
    type Output = Quantity<u16, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for u32 {
    type Output = Quantity<u32, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for u64 {
    type Output = Quantity<u64, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for u128 {
    type Output = Quantity<u128, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for usize {
    type Output = Quantity<usize, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for f32 {
    type Output = Quantity<f32, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
impl Mul<UnitFemtohenriesMul> for f64 {
    type Output = Quantity<f64, UnitFemtohenries>;
    fn mul(self, _: UnitFemtohenriesMul) -> Self::Output {
        Quantity::new(self, UnitFemtohenries)
    }
}
pub struct UnitAttohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohenries {
    #[inline]
    fn clone(&self) -> UnitAttohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohenries {
    #[inline]
    fn eq(&self, other: &UnitAttohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttohenries {
    fn default() -> Self {
        UnitAttohenries
    }
}
impl Add<UnitAttohenries> for UnitAttohenries {
    type Output = UnitAttohenries;
    #[inline]
    fn add(self, _: UnitAttohenries) -> Self::Output {
        UnitAttohenries
    }
}
impl AddAssign<UnitAttohenries> for UnitAttohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitAttohenries) {}
}
impl Sub<UnitAttohenries> for UnitAttohenries {
    type Output = UnitAttohenries;
    #[inline]
    fn sub(self, _: UnitAttohenries) -> Self::Output {
        UnitAttohenries
    }
}
impl SubAssign<UnitAttohenries> for UnitAttohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttohenries) {}
}
pub struct UnitAttohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohenriesMul {
    #[inline]
    fn clone(&self) -> UnitAttohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitAttohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttohenriesMul> for i8 {
    type Output = Quantity<i8, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for i16 {
    type Output = Quantity<i16, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for i32 {
    type Output = Quantity<i32, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for i64 {
    type Output = Quantity<i64, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for i128 {
    type Output = Quantity<i128, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for isize {
    type Output = Quantity<isize, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for u8 {
    type Output = Quantity<u8, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for u16 {
    type Output = Quantity<u16, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for u32 {
    type Output = Quantity<u32, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for u64 {
    type Output = Quantity<u64, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for u128 {
    type Output = Quantity<u128, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for usize {
    type Output = Quantity<usize, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for f32 {
    type Output = Quantity<f32, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
impl Mul<UnitAttohenriesMul> for f64 {
    type Output = Quantity<f64, UnitAttohenries>;
    fn mul(self, _: UnitAttohenriesMul) -> Self::Output {
        Quantity::new(self, UnitAttohenries)
    }
}
pub struct UnitZeptohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohenries {
    #[inline]
    fn clone(&self) -> UnitZeptohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohenries {
    #[inline]
    fn eq(&self, other: &UnitZeptohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptohenries {
    fn default() -> Self {
        UnitZeptohenries
    }
}
impl Add<UnitZeptohenries> for UnitZeptohenries {
    type Output = UnitZeptohenries;
    #[inline]
    fn add(self, _: UnitZeptohenries) -> Self::Output {
        UnitZeptohenries
    }
}
impl AddAssign<UnitZeptohenries> for UnitZeptohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptohenries) {}
}
impl Sub<UnitZeptohenries> for UnitZeptohenries {
    type Output = UnitZeptohenries;
    #[inline]
    fn sub(self, _: UnitZeptohenries) -> Self::Output {
        UnitZeptohenries
    }
}
impl SubAssign<UnitZeptohenries> for UnitZeptohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptohenries) {}
}
pub struct UnitZeptohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohenriesMul {
    #[inline]
    fn clone(&self) -> UnitZeptohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptohenriesMul> for i8 {
    type Output = Quantity<i8, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for i16 {
    type Output = Quantity<i16, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for i32 {
    type Output = Quantity<i32, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for i64 {
    type Output = Quantity<i64, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for i128 {
    type Output = Quantity<i128, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for isize {
    type Output = Quantity<isize, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for u8 {
    type Output = Quantity<u8, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for u16 {
    type Output = Quantity<u16, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for u32 {
    type Output = Quantity<u32, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for u64 {
    type Output = Quantity<u64, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for u128 {
    type Output = Quantity<u128, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for usize {
    type Output = Quantity<usize, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for f32 {
    type Output = Quantity<f32, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
impl Mul<UnitZeptohenriesMul> for f64 {
    type Output = Quantity<f64, UnitZeptohenries>;
    fn mul(self, _: UnitZeptohenriesMul) -> Self::Output {
        Quantity::new(self, UnitZeptohenries)
    }
}
pub struct UnitYoctohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohenries {
    #[inline]
    fn clone(&self) -> UnitYoctohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohenries {
    #[inline]
    fn eq(&self, other: &UnitYoctohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctohenries {
    fn default() -> Self {
        UnitYoctohenries
    }
}
impl Add<UnitYoctohenries> for UnitYoctohenries {
    type Output = UnitYoctohenries;
    #[inline]
    fn add(self, _: UnitYoctohenries) -> Self::Output {
        UnitYoctohenries
    }
}
impl AddAssign<UnitYoctohenries> for UnitYoctohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctohenries) {}
}
impl Sub<UnitYoctohenries> for UnitYoctohenries {
    type Output = UnitYoctohenries;
    #[inline]
    fn sub(self, _: UnitYoctohenries) -> Self::Output {
        UnitYoctohenries
    }
}
impl SubAssign<UnitYoctohenries> for UnitYoctohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctohenries) {}
}
pub struct UnitYoctohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohenriesMul {
    #[inline]
    fn clone(&self) -> UnitYoctohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctohenriesMul> for i8 {
    type Output = Quantity<i8, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for i16 {
    type Output = Quantity<i16, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for i32 {
    type Output = Quantity<i32, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for i64 {
    type Output = Quantity<i64, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for i128 {
    type Output = Quantity<i128, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for isize {
    type Output = Quantity<isize, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for u8 {
    type Output = Quantity<u8, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for u16 {
    type Output = Quantity<u16, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for u32 {
    type Output = Quantity<u32, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for u64 {
    type Output = Quantity<u64, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for u128 {
    type Output = Quantity<u128, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for usize {
    type Output = Quantity<usize, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for f32 {
    type Output = Quantity<f32, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
impl Mul<UnitYoctohenriesMul> for f64 {
    type Output = Quantity<f64, UnitYoctohenries>;
    fn mul(self, _: UnitYoctohenriesMul) -> Self::Output {
        Quantity::new(self, UnitYoctohenries)
    }
}
pub struct UnitRontohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohenries {
    #[inline]
    fn clone(&self) -> UnitRontohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohenries {
    #[inline]
    fn eq(&self, other: &UnitRontohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontohenries {
    fn default() -> Self {
        UnitRontohenries
    }
}
impl Add<UnitRontohenries> for UnitRontohenries {
    type Output = UnitRontohenries;
    #[inline]
    fn add(self, _: UnitRontohenries) -> Self::Output {
        UnitRontohenries
    }
}
impl AddAssign<UnitRontohenries> for UnitRontohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitRontohenries) {}
}
impl Sub<UnitRontohenries> for UnitRontohenries {
    type Output = UnitRontohenries;
    #[inline]
    fn sub(self, _: UnitRontohenries) -> Self::Output {
        UnitRontohenries
    }
}
impl SubAssign<UnitRontohenries> for UnitRontohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontohenries) {}
}
pub struct UnitRontohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohenriesMul {
    #[inline]
    fn clone(&self) -> UnitRontohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitRontohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontohenriesMul> for i8 {
    type Output = Quantity<i8, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for i16 {
    type Output = Quantity<i16, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for i32 {
    type Output = Quantity<i32, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for i64 {
    type Output = Quantity<i64, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for i128 {
    type Output = Quantity<i128, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for isize {
    type Output = Quantity<isize, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for u8 {
    type Output = Quantity<u8, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for u16 {
    type Output = Quantity<u16, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for u32 {
    type Output = Quantity<u32, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for u64 {
    type Output = Quantity<u64, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for u128 {
    type Output = Quantity<u128, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for usize {
    type Output = Quantity<usize, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for f32 {
    type Output = Quantity<f32, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
impl Mul<UnitRontohenriesMul> for f64 {
    type Output = Quantity<f64, UnitRontohenries>;
    fn mul(self, _: UnitRontohenriesMul) -> Self::Output {
        Quantity::new(self, UnitRontohenries)
    }
}
pub struct UnitQuectohenries;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohenries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohenries")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohenries {
    #[inline]
    fn clone(&self) -> UnitQuectohenries {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohenries {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohenries {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohenries {
    #[inline]
    fn eq(&self, other: &UnitQuectohenries) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohenries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectohenries {
    fn default() -> Self {
        UnitQuectohenries
    }
}
impl Add<UnitQuectohenries> for UnitQuectohenries {
    type Output = UnitQuectohenries;
    #[inline]
    fn add(self, _: UnitQuectohenries) -> Self::Output {
        UnitQuectohenries
    }
}
impl AddAssign<UnitQuectohenries> for UnitQuectohenries {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectohenries) {}
}
impl Sub<UnitQuectohenries> for UnitQuectohenries {
    type Output = UnitQuectohenries;
    #[inline]
    fn sub(self, _: UnitQuectohenries) -> Self::Output {
        UnitQuectohenries
    }
}
impl SubAssign<UnitQuectohenries> for UnitQuectohenries {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectohenries) {}
}
pub struct UnitQuectohenriesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohenriesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohenriesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohenriesMul {
    #[inline]
    fn clone(&self) -> UnitQuectohenriesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohenriesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohenriesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohenriesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectohenriesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohenriesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectohenriesMul> for i8 {
    type Output = Quantity<i8, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for i16 {
    type Output = Quantity<i16, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for i32 {
    type Output = Quantity<i32, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for i64 {
    type Output = Quantity<i64, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for i128 {
    type Output = Quantity<i128, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for isize {
    type Output = Quantity<isize, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for u8 {
    type Output = Quantity<u8, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for u16 {
    type Output = Quantity<u16, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for u32 {
    type Output = Quantity<u32, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for u64 {
    type Output = Quantity<u64, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for u128 {
    type Output = Quantity<u128, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for usize {
    type Output = Quantity<usize, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for f32 {
    type Output = Quantity<f32, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
impl Mul<UnitQuectohenriesMul> for f64 {
    type Output = Quantity<f64, UnitQuectohenries>;
    fn mul(self, _: UnitQuectohenriesMul) -> Self::Output {
        Quantity::new(self, UnitQuectohenries)
    }
}
pub type Henries<T> = Quantity<T, UnitHenries>;
#[allow(non_upper_case_globals)]
pub static Henries: UnitHenriesMul = UnitHenriesMul;
pub type Quettahenries<T> = Quantity<T, UnitQuettahenries>;
#[allow(non_upper_case_globals)]
pub static Quettahenries: UnitQuettahenriesMul = UnitQuettahenriesMul;
pub type Ronnahenries<T> = Quantity<T, UnitRonnahenries>;
#[allow(non_upper_case_globals)]
pub static Ronnahenries: UnitRonnahenriesMul = UnitRonnahenriesMul;
pub type Yottahenries<T> = Quantity<T, UnitYottahenries>;
#[allow(non_upper_case_globals)]
pub static Yottahenries: UnitYottahenriesMul = UnitYottahenriesMul;
pub type Zettahenries<T> = Quantity<T, UnitZettahenries>;
#[allow(non_upper_case_globals)]
pub static Zettahenries: UnitZettahenriesMul = UnitZettahenriesMul;
pub type Exahenries<T> = Quantity<T, UnitExahenries>;
#[allow(non_upper_case_globals)]
pub static Exahenries: UnitExahenriesMul = UnitExahenriesMul;
pub type Petahenries<T> = Quantity<T, UnitPetahenries>;
#[allow(non_upper_case_globals)]
pub static Petahenries: UnitPetahenriesMul = UnitPetahenriesMul;
pub type Terahenries<T> = Quantity<T, UnitTerahenries>;
#[allow(non_upper_case_globals)]
pub static Terahenries: UnitTerahenriesMul = UnitTerahenriesMul;
pub type Gigahenries<T> = Quantity<T, UnitGigahenries>;
#[allow(non_upper_case_globals)]
pub static Gigahenries: UnitGigahenriesMul = UnitGigahenriesMul;
pub type Megahenries<T> = Quantity<T, UnitMegahenries>;
#[allow(non_upper_case_globals)]
pub static Megahenries: UnitMegahenriesMul = UnitMegahenriesMul;
pub type Kilohenries<T> = Quantity<T, UnitKilohenries>;
#[allow(non_upper_case_globals)]
pub static Kilohenries: UnitKilohenriesMul = UnitKilohenriesMul;
pub type Hectohenries<T> = Quantity<T, UnitHectohenries>;
#[allow(non_upper_case_globals)]
pub static Hectohenries: UnitHectohenriesMul = UnitHectohenriesMul;
pub type Decahenries<T> = Quantity<T, UnitDecahenries>;
#[allow(non_upper_case_globals)]
pub static Decahenries: UnitDecahenriesMul = UnitDecahenriesMul;
pub type Decihenries<T> = Quantity<T, UnitDecihenries>;
#[allow(non_upper_case_globals)]
pub static Decihenries: UnitDecihenriesMul = UnitDecihenriesMul;
pub type Centihenries<T> = Quantity<T, UnitCentihenries>;
#[allow(non_upper_case_globals)]
pub static Centihenries: UnitCentihenriesMul = UnitCentihenriesMul;
pub type Millihenries<T> = Quantity<T, UnitMillihenries>;
#[allow(non_upper_case_globals)]
pub static Millihenries: UnitMillihenriesMul = UnitMillihenriesMul;
pub type Microhenries<T> = Quantity<T, UnitMicrohenries>;
#[allow(non_upper_case_globals)]
pub static Microhenries: UnitMicrohenriesMul = UnitMicrohenriesMul;
pub type Nanohenries<T> = Quantity<T, UnitNanohenries>;
#[allow(non_upper_case_globals)]
pub static Nanohenries: UnitNanohenriesMul = UnitNanohenriesMul;
pub type Picohenries<T> = Quantity<T, UnitPicohenries>;
#[allow(non_upper_case_globals)]
pub static Picohenries: UnitPicohenriesMul = UnitPicohenriesMul;
pub type Femtohenries<T> = Quantity<T, UnitFemtohenries>;
#[allow(non_upper_case_globals)]
pub static Femtohenries: UnitFemtohenriesMul = UnitFemtohenriesMul;
pub type Attohenries<T> = Quantity<T, UnitAttohenries>;
#[allow(non_upper_case_globals)]
pub static Attohenries: UnitAttohenriesMul = UnitAttohenriesMul;
pub type Zeptohenries<T> = Quantity<T, UnitZeptohenries>;
#[allow(non_upper_case_globals)]
pub static Zeptohenries: UnitZeptohenriesMul = UnitZeptohenriesMul;
pub type Yoctohenries<T> = Quantity<T, UnitYoctohenries>;
#[allow(non_upper_case_globals)]
pub static Yoctohenries: UnitYoctohenriesMul = UnitYoctohenriesMul;
pub type Rontohenries<T> = Quantity<T, UnitRontohenries>;
#[allow(non_upper_case_globals)]
pub static Rontohenries: UnitRontohenriesMul = UnitRontohenriesMul;
pub type Quectohenries<T> = Quantity<T, UnitQuectohenries>;
#[allow(non_upper_case_globals)]
pub static Quectohenries: UnitQuectohenriesMul = UnitQuectohenriesMul;
pub struct UnitCelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCelsius {
    #[inline]
    fn clone(&self) -> UnitCelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCelsius {
    #[inline]
    fn eq(&self, other: &UnitCelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCelsius {
    fn default() -> Self {
        UnitCelsius
    }
}
impl Add<UnitCelsius> for UnitCelsius {
    type Output = UnitCelsius;
    #[inline]
    fn add(self, _: UnitCelsius) -> Self::Output {
        UnitCelsius
    }
}
impl AddAssign<UnitCelsius> for UnitCelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitCelsius) {}
}
impl Sub<UnitCelsius> for UnitCelsius {
    type Output = UnitCelsius;
    #[inline]
    fn sub(self, _: UnitCelsius) -> Self::Output {
        UnitCelsius
    }
}
impl SubAssign<UnitCelsius> for UnitCelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitCelsius) {}
}
pub struct UnitCelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCelsiusMul {
    #[inline]
    fn clone(&self) -> UnitCelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitCelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCelsiusMul> for i8 {
    type Output = Quantity<i8, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for i16 {
    type Output = Quantity<i16, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for i32 {
    type Output = Quantity<i32, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for i64 {
    type Output = Quantity<i64, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for i128 {
    type Output = Quantity<i128, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for isize {
    type Output = Quantity<isize, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for u8 {
    type Output = Quantity<u8, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for u16 {
    type Output = Quantity<u16, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for u32 {
    type Output = Quantity<u32, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for u64 {
    type Output = Quantity<u64, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for u128 {
    type Output = Quantity<u128, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for usize {
    type Output = Quantity<usize, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for f32 {
    type Output = Quantity<f32, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
impl Mul<UnitCelsiusMul> for f64 {
    type Output = Quantity<f64, UnitCelsius>;
    fn mul(self, _: UnitCelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCelsius)
    }
}
pub struct UnitQuettacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacelsius {
    #[inline]
    fn clone(&self) -> UnitQuettacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacelsius {
    #[inline]
    fn eq(&self, other: &UnitQuettacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettacelsius {
    fn default() -> Self {
        UnitQuettacelsius
    }
}
impl Add<UnitQuettacelsius> for UnitQuettacelsius {
    type Output = UnitQuettacelsius;
    #[inline]
    fn add(self, _: UnitQuettacelsius) -> Self::Output {
        UnitQuettacelsius
    }
}
impl AddAssign<UnitQuettacelsius> for UnitQuettacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettacelsius) {}
}
impl Sub<UnitQuettacelsius> for UnitQuettacelsius {
    type Output = UnitQuettacelsius;
    #[inline]
    fn sub(self, _: UnitQuettacelsius) -> Self::Output {
        UnitQuettacelsius
    }
}
impl SubAssign<UnitQuettacelsius> for UnitQuettacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettacelsius) {}
}
pub struct UnitQuettacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitQuettacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitQuettacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for isize {
    type Output = Quantity<isize, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for usize {
    type Output = Quantity<usize, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
impl Mul<UnitQuettacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitQuettacelsius>;
    fn mul(self, _: UnitQuettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuettacelsius)
    }
}
pub struct UnitRonnacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacelsius {
    #[inline]
    fn clone(&self) -> UnitRonnacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacelsius {
    #[inline]
    fn eq(&self, other: &UnitRonnacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnacelsius {
    fn default() -> Self {
        UnitRonnacelsius
    }
}
impl Add<UnitRonnacelsius> for UnitRonnacelsius {
    type Output = UnitRonnacelsius;
    #[inline]
    fn add(self, _: UnitRonnacelsius) -> Self::Output {
        UnitRonnacelsius
    }
}
impl AddAssign<UnitRonnacelsius> for UnitRonnacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnacelsius) {}
}
impl Sub<UnitRonnacelsius> for UnitRonnacelsius {
    type Output = UnitRonnacelsius;
    #[inline]
    fn sub(self, _: UnitRonnacelsius) -> Self::Output {
        UnitRonnacelsius
    }
}
impl SubAssign<UnitRonnacelsius> for UnitRonnacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnacelsius) {}
}
pub struct UnitRonnacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitRonnacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitRonnacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for isize {
    type Output = Quantity<isize, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for usize {
    type Output = Quantity<usize, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
impl Mul<UnitRonnacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitRonnacelsius>;
    fn mul(self, _: UnitRonnacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRonnacelsius)
    }
}
pub struct UnitYottacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacelsius {
    #[inline]
    fn clone(&self) -> UnitYottacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacelsius {
    #[inline]
    fn eq(&self, other: &UnitYottacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottacelsius {
    fn default() -> Self {
        UnitYottacelsius
    }
}
impl Add<UnitYottacelsius> for UnitYottacelsius {
    type Output = UnitYottacelsius;
    #[inline]
    fn add(self, _: UnitYottacelsius) -> Self::Output {
        UnitYottacelsius
    }
}
impl AddAssign<UnitYottacelsius> for UnitYottacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitYottacelsius) {}
}
impl Sub<UnitYottacelsius> for UnitYottacelsius {
    type Output = UnitYottacelsius;
    #[inline]
    fn sub(self, _: UnitYottacelsius) -> Self::Output {
        UnitYottacelsius
    }
}
impl SubAssign<UnitYottacelsius> for UnitYottacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottacelsius) {}
}
pub struct UnitYottacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitYottacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitYottacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for isize {
    type Output = Quantity<isize, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for usize {
    type Output = Quantity<usize, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
impl Mul<UnitYottacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitYottacelsius>;
    fn mul(self, _: UnitYottacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYottacelsius)
    }
}
pub struct UnitZettacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacelsius {
    #[inline]
    fn clone(&self) -> UnitZettacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacelsius {
    #[inline]
    fn eq(&self, other: &UnitZettacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettacelsius {
    fn default() -> Self {
        UnitZettacelsius
    }
}
impl Add<UnitZettacelsius> for UnitZettacelsius {
    type Output = UnitZettacelsius;
    #[inline]
    fn add(self, _: UnitZettacelsius) -> Self::Output {
        UnitZettacelsius
    }
}
impl AddAssign<UnitZettacelsius> for UnitZettacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitZettacelsius) {}
}
impl Sub<UnitZettacelsius> for UnitZettacelsius {
    type Output = UnitZettacelsius;
    #[inline]
    fn sub(self, _: UnitZettacelsius) -> Self::Output {
        UnitZettacelsius
    }
}
impl SubAssign<UnitZettacelsius> for UnitZettacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettacelsius) {}
}
pub struct UnitZettacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitZettacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitZettacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for isize {
    type Output = Quantity<isize, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for usize {
    type Output = Quantity<usize, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
impl Mul<UnitZettacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitZettacelsius>;
    fn mul(self, _: UnitZettacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZettacelsius)
    }
}
pub struct UnitExacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacelsius {
    #[inline]
    fn clone(&self) -> UnitExacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacelsius {
    #[inline]
    fn eq(&self, other: &UnitExacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExacelsius {
    fn default() -> Self {
        UnitExacelsius
    }
}
impl Add<UnitExacelsius> for UnitExacelsius {
    type Output = UnitExacelsius;
    #[inline]
    fn add(self, _: UnitExacelsius) -> Self::Output {
        UnitExacelsius
    }
}
impl AddAssign<UnitExacelsius> for UnitExacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitExacelsius) {}
}
impl Sub<UnitExacelsius> for UnitExacelsius {
    type Output = UnitExacelsius;
    #[inline]
    fn sub(self, _: UnitExacelsius) -> Self::Output {
        UnitExacelsius
    }
}
impl SubAssign<UnitExacelsius> for UnitExacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitExacelsius) {}
}
pub struct UnitExacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitExacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitExacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for isize {
    type Output = Quantity<isize, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for usize {
    type Output = Quantity<usize, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
impl Mul<UnitExacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitExacelsius>;
    fn mul(self, _: UnitExacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitExacelsius)
    }
}
pub struct UnitPetacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacelsius {
    #[inline]
    fn clone(&self) -> UnitPetacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacelsius {
    #[inline]
    fn eq(&self, other: &UnitPetacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetacelsius {
    fn default() -> Self {
        UnitPetacelsius
    }
}
impl Add<UnitPetacelsius> for UnitPetacelsius {
    type Output = UnitPetacelsius;
    #[inline]
    fn add(self, _: UnitPetacelsius) -> Self::Output {
        UnitPetacelsius
    }
}
impl AddAssign<UnitPetacelsius> for UnitPetacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitPetacelsius) {}
}
impl Sub<UnitPetacelsius> for UnitPetacelsius {
    type Output = UnitPetacelsius;
    #[inline]
    fn sub(self, _: UnitPetacelsius) -> Self::Output {
        UnitPetacelsius
    }
}
impl SubAssign<UnitPetacelsius> for UnitPetacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetacelsius) {}
}
pub struct UnitPetacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitPetacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitPetacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for isize {
    type Output = Quantity<isize, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for usize {
    type Output = Quantity<usize, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
impl Mul<UnitPetacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitPetacelsius>;
    fn mul(self, _: UnitPetacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPetacelsius)
    }
}
pub struct UnitTeracelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracelsius {
    #[inline]
    fn clone(&self) -> UnitTeracelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracelsius {
    #[inline]
    fn eq(&self, other: &UnitTeracelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeracelsius {
    fn default() -> Self {
        UnitTeracelsius
    }
}
impl Add<UnitTeracelsius> for UnitTeracelsius {
    type Output = UnitTeracelsius;
    #[inline]
    fn add(self, _: UnitTeracelsius) -> Self::Output {
        UnitTeracelsius
    }
}
impl AddAssign<UnitTeracelsius> for UnitTeracelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitTeracelsius) {}
}
impl Sub<UnitTeracelsius> for UnitTeracelsius {
    type Output = UnitTeracelsius;
    #[inline]
    fn sub(self, _: UnitTeracelsius) -> Self::Output {
        UnitTeracelsius
    }
}
impl SubAssign<UnitTeracelsius> for UnitTeracelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeracelsius) {}
}
pub struct UnitTeracelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeracelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeracelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeracelsiusMul {
    #[inline]
    fn clone(&self) -> UnitTeracelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeracelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeracelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeracelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitTeracelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeracelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeracelsiusMul> for i8 {
    type Output = Quantity<i8, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for i16 {
    type Output = Quantity<i16, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for i32 {
    type Output = Quantity<i32, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for i64 {
    type Output = Quantity<i64, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for i128 {
    type Output = Quantity<i128, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for isize {
    type Output = Quantity<isize, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for u8 {
    type Output = Quantity<u8, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for u16 {
    type Output = Quantity<u16, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for u32 {
    type Output = Quantity<u32, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for u64 {
    type Output = Quantity<u64, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for u128 {
    type Output = Quantity<u128, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for usize {
    type Output = Quantity<usize, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for f32 {
    type Output = Quantity<f32, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
impl Mul<UnitTeracelsiusMul> for f64 {
    type Output = Quantity<f64, UnitTeracelsius>;
    fn mul(self, _: UnitTeracelsiusMul) -> Self::Output {
        Quantity::new(self, UnitTeracelsius)
    }
}
pub struct UnitGigacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacelsius {
    #[inline]
    fn clone(&self) -> UnitGigacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacelsius {
    #[inline]
    fn eq(&self, other: &UnitGigacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigacelsius {
    fn default() -> Self {
        UnitGigacelsius
    }
}
impl Add<UnitGigacelsius> for UnitGigacelsius {
    type Output = UnitGigacelsius;
    #[inline]
    fn add(self, _: UnitGigacelsius) -> Self::Output {
        UnitGigacelsius
    }
}
impl AddAssign<UnitGigacelsius> for UnitGigacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitGigacelsius) {}
}
impl Sub<UnitGigacelsius> for UnitGigacelsius {
    type Output = UnitGigacelsius;
    #[inline]
    fn sub(self, _: UnitGigacelsius) -> Self::Output {
        UnitGigacelsius
    }
}
impl SubAssign<UnitGigacelsius> for UnitGigacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigacelsius) {}
}
pub struct UnitGigacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitGigacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitGigacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for isize {
    type Output = Quantity<isize, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for usize {
    type Output = Quantity<usize, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
impl Mul<UnitGigacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitGigacelsius>;
    fn mul(self, _: UnitGigacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitGigacelsius)
    }
}
pub struct UnitMegacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacelsius {
    #[inline]
    fn clone(&self) -> UnitMegacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacelsius {
    #[inline]
    fn eq(&self, other: &UnitMegacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegacelsius {
    fn default() -> Self {
        UnitMegacelsius
    }
}
impl Add<UnitMegacelsius> for UnitMegacelsius {
    type Output = UnitMegacelsius;
    #[inline]
    fn add(self, _: UnitMegacelsius) -> Self::Output {
        UnitMegacelsius
    }
}
impl AddAssign<UnitMegacelsius> for UnitMegacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitMegacelsius) {}
}
impl Sub<UnitMegacelsius> for UnitMegacelsius {
    type Output = UnitMegacelsius;
    #[inline]
    fn sub(self, _: UnitMegacelsius) -> Self::Output {
        UnitMegacelsius
    }
}
impl SubAssign<UnitMegacelsius> for UnitMegacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegacelsius) {}
}
pub struct UnitMegacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitMegacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitMegacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for isize {
    type Output = Quantity<isize, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for usize {
    type Output = Quantity<usize, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
impl Mul<UnitMegacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitMegacelsius>;
    fn mul(self, _: UnitMegacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMegacelsius)
    }
}
pub struct UnitKilocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocelsius {
    #[inline]
    fn clone(&self) -> UnitKilocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocelsius {
    #[inline]
    fn eq(&self, other: &UnitKilocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilocelsius {
    fn default() -> Self {
        UnitKilocelsius
    }
}
impl Add<UnitKilocelsius> for UnitKilocelsius {
    type Output = UnitKilocelsius;
    #[inline]
    fn add(self, _: UnitKilocelsius) -> Self::Output {
        UnitKilocelsius
    }
}
impl AddAssign<UnitKilocelsius> for UnitKilocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitKilocelsius) {}
}
impl Sub<UnitKilocelsius> for UnitKilocelsius {
    type Output = UnitKilocelsius;
    #[inline]
    fn sub(self, _: UnitKilocelsius) -> Self::Output {
        UnitKilocelsius
    }
}
impl SubAssign<UnitKilocelsius> for UnitKilocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilocelsius) {}
}
pub struct UnitKilocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitKilocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitKilocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for isize {
    type Output = Quantity<isize, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for usize {
    type Output = Quantity<usize, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
impl Mul<UnitKilocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitKilocelsius>;
    fn mul(self, _: UnitKilocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitKilocelsius)
    }
}
pub struct UnitHectocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocelsius {
    #[inline]
    fn clone(&self) -> UnitHectocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocelsius {
    #[inline]
    fn eq(&self, other: &UnitHectocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectocelsius {
    fn default() -> Self {
        UnitHectocelsius
    }
}
impl Add<UnitHectocelsius> for UnitHectocelsius {
    type Output = UnitHectocelsius;
    #[inline]
    fn add(self, _: UnitHectocelsius) -> Self::Output {
        UnitHectocelsius
    }
}
impl AddAssign<UnitHectocelsius> for UnitHectocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitHectocelsius) {}
}
impl Sub<UnitHectocelsius> for UnitHectocelsius {
    type Output = UnitHectocelsius;
    #[inline]
    fn sub(self, _: UnitHectocelsius) -> Self::Output {
        UnitHectocelsius
    }
}
impl SubAssign<UnitHectocelsius> for UnitHectocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectocelsius) {}
}
pub struct UnitHectocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitHectocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitHectocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for isize {
    type Output = Quantity<isize, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for usize {
    type Output = Quantity<usize, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
impl Mul<UnitHectocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitHectocelsius>;
    fn mul(self, _: UnitHectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitHectocelsius)
    }
}
pub struct UnitDecacelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacelsius {
    #[inline]
    fn clone(&self) -> UnitDecacelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacelsius {
    #[inline]
    fn eq(&self, other: &UnitDecacelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecacelsius {
    fn default() -> Self {
        UnitDecacelsius
    }
}
impl Add<UnitDecacelsius> for UnitDecacelsius {
    type Output = UnitDecacelsius;
    #[inline]
    fn add(self, _: UnitDecacelsius) -> Self::Output {
        UnitDecacelsius
    }
}
impl AddAssign<UnitDecacelsius> for UnitDecacelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitDecacelsius) {}
}
impl Sub<UnitDecacelsius> for UnitDecacelsius {
    type Output = UnitDecacelsius;
    #[inline]
    fn sub(self, _: UnitDecacelsius) -> Self::Output {
        UnitDecacelsius
    }
}
impl SubAssign<UnitDecacelsius> for UnitDecacelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecacelsius) {}
}
pub struct UnitDecacelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecacelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecacelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecacelsiusMul {
    #[inline]
    fn clone(&self) -> UnitDecacelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecacelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecacelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecacelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitDecacelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecacelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecacelsiusMul> for i8 {
    type Output = Quantity<i8, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for i16 {
    type Output = Quantity<i16, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for i32 {
    type Output = Quantity<i32, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for i64 {
    type Output = Quantity<i64, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for i128 {
    type Output = Quantity<i128, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for isize {
    type Output = Quantity<isize, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for u8 {
    type Output = Quantity<u8, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for u16 {
    type Output = Quantity<u16, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for u32 {
    type Output = Quantity<u32, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for u64 {
    type Output = Quantity<u64, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for u128 {
    type Output = Quantity<u128, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for usize {
    type Output = Quantity<usize, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for f32 {
    type Output = Quantity<f32, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
impl Mul<UnitDecacelsiusMul> for f64 {
    type Output = Quantity<f64, UnitDecacelsius>;
    fn mul(self, _: UnitDecacelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecacelsius)
    }
}
pub struct UnitDecicelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicelsius {
    #[inline]
    fn clone(&self) -> UnitDecicelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicelsius {
    #[inline]
    fn eq(&self, other: &UnitDecicelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecicelsius {
    fn default() -> Self {
        UnitDecicelsius
    }
}
impl Add<UnitDecicelsius> for UnitDecicelsius {
    type Output = UnitDecicelsius;
    #[inline]
    fn add(self, _: UnitDecicelsius) -> Self::Output {
        UnitDecicelsius
    }
}
impl AddAssign<UnitDecicelsius> for UnitDecicelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitDecicelsius) {}
}
impl Sub<UnitDecicelsius> for UnitDecicelsius {
    type Output = UnitDecicelsius;
    #[inline]
    fn sub(self, _: UnitDecicelsius) -> Self::Output {
        UnitDecicelsius
    }
}
impl SubAssign<UnitDecicelsius> for UnitDecicelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecicelsius) {}
}
pub struct UnitDecicelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecicelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecicelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecicelsiusMul {
    #[inline]
    fn clone(&self) -> UnitDecicelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecicelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecicelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecicelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitDecicelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecicelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecicelsiusMul> for i8 {
    type Output = Quantity<i8, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for i16 {
    type Output = Quantity<i16, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for i32 {
    type Output = Quantity<i32, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for i64 {
    type Output = Quantity<i64, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for i128 {
    type Output = Quantity<i128, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for isize {
    type Output = Quantity<isize, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for u8 {
    type Output = Quantity<u8, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for u16 {
    type Output = Quantity<u16, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for u32 {
    type Output = Quantity<u32, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for u64 {
    type Output = Quantity<u64, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for u128 {
    type Output = Quantity<u128, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for usize {
    type Output = Quantity<usize, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for f32 {
    type Output = Quantity<f32, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
impl Mul<UnitDecicelsiusMul> for f64 {
    type Output = Quantity<f64, UnitDecicelsius>;
    fn mul(self, _: UnitDecicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitDecicelsius)
    }
}
pub struct UnitCenticelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticelsius {
    #[inline]
    fn clone(&self) -> UnitCenticelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticelsius {
    #[inline]
    fn eq(&self, other: &UnitCenticelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCenticelsius {
    fn default() -> Self {
        UnitCenticelsius
    }
}
impl Add<UnitCenticelsius> for UnitCenticelsius {
    type Output = UnitCenticelsius;
    #[inline]
    fn add(self, _: UnitCenticelsius) -> Self::Output {
        UnitCenticelsius
    }
}
impl AddAssign<UnitCenticelsius> for UnitCenticelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitCenticelsius) {}
}
impl Sub<UnitCenticelsius> for UnitCenticelsius {
    type Output = UnitCenticelsius;
    #[inline]
    fn sub(self, _: UnitCenticelsius) -> Self::Output {
        UnitCenticelsius
    }
}
impl SubAssign<UnitCenticelsius> for UnitCenticelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitCenticelsius) {}
}
pub struct UnitCenticelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCenticelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCenticelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCenticelsiusMul {
    #[inline]
    fn clone(&self) -> UnitCenticelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCenticelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCenticelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCenticelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitCenticelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCenticelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCenticelsiusMul> for i8 {
    type Output = Quantity<i8, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for i16 {
    type Output = Quantity<i16, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for i32 {
    type Output = Quantity<i32, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for i64 {
    type Output = Quantity<i64, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for i128 {
    type Output = Quantity<i128, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for isize {
    type Output = Quantity<isize, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for u8 {
    type Output = Quantity<u8, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for u16 {
    type Output = Quantity<u16, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for u32 {
    type Output = Quantity<u32, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for u64 {
    type Output = Quantity<u64, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for u128 {
    type Output = Quantity<u128, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for usize {
    type Output = Quantity<usize, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for f32 {
    type Output = Quantity<f32, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
impl Mul<UnitCenticelsiusMul> for f64 {
    type Output = Quantity<f64, UnitCenticelsius>;
    fn mul(self, _: UnitCenticelsiusMul) -> Self::Output {
        Quantity::new(self, UnitCenticelsius)
    }
}
pub struct UnitMillicelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicelsius {
    #[inline]
    fn clone(&self) -> UnitMillicelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicelsius {
    #[inline]
    fn eq(&self, other: &UnitMillicelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillicelsius {
    fn default() -> Self {
        UnitMillicelsius
    }
}
impl Add<UnitMillicelsius> for UnitMillicelsius {
    type Output = UnitMillicelsius;
    #[inline]
    fn add(self, _: UnitMillicelsius) -> Self::Output {
        UnitMillicelsius
    }
}
impl AddAssign<UnitMillicelsius> for UnitMillicelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitMillicelsius) {}
}
impl Sub<UnitMillicelsius> for UnitMillicelsius {
    type Output = UnitMillicelsius;
    #[inline]
    fn sub(self, _: UnitMillicelsius) -> Self::Output {
        UnitMillicelsius
    }
}
impl SubAssign<UnitMillicelsius> for UnitMillicelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillicelsius) {}
}
pub struct UnitMillicelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillicelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillicelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillicelsiusMul {
    #[inline]
    fn clone(&self) -> UnitMillicelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillicelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillicelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillicelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitMillicelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillicelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillicelsiusMul> for i8 {
    type Output = Quantity<i8, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for i16 {
    type Output = Quantity<i16, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for i32 {
    type Output = Quantity<i32, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for i64 {
    type Output = Quantity<i64, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for i128 {
    type Output = Quantity<i128, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for isize {
    type Output = Quantity<isize, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for u8 {
    type Output = Quantity<u8, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for u16 {
    type Output = Quantity<u16, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for u32 {
    type Output = Quantity<u32, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for u64 {
    type Output = Quantity<u64, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for u128 {
    type Output = Quantity<u128, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for usize {
    type Output = Quantity<usize, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for f32 {
    type Output = Quantity<f32, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
impl Mul<UnitMillicelsiusMul> for f64 {
    type Output = Quantity<f64, UnitMillicelsius>;
    fn mul(self, _: UnitMillicelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMillicelsius)
    }
}
pub struct UnitMicrocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocelsius {
    #[inline]
    fn clone(&self) -> UnitMicrocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocelsius {
    #[inline]
    fn eq(&self, other: &UnitMicrocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrocelsius {
    fn default() -> Self {
        UnitMicrocelsius
    }
}
impl Add<UnitMicrocelsius> for UnitMicrocelsius {
    type Output = UnitMicrocelsius;
    #[inline]
    fn add(self, _: UnitMicrocelsius) -> Self::Output {
        UnitMicrocelsius
    }
}
impl AddAssign<UnitMicrocelsius> for UnitMicrocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrocelsius) {}
}
impl Sub<UnitMicrocelsius> for UnitMicrocelsius {
    type Output = UnitMicrocelsius;
    #[inline]
    fn sub(self, _: UnitMicrocelsius) -> Self::Output {
        UnitMicrocelsius
    }
}
impl SubAssign<UnitMicrocelsius> for UnitMicrocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrocelsius) {}
}
pub struct UnitMicrocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitMicrocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitMicrocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for isize {
    type Output = Quantity<isize, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for usize {
    type Output = Quantity<usize, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
impl Mul<UnitMicrocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitMicrocelsius>;
    fn mul(self, _: UnitMicrocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitMicrocelsius)
    }
}
pub struct UnitNanocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocelsius {
    #[inline]
    fn clone(&self) -> UnitNanocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocelsius {
    #[inline]
    fn eq(&self, other: &UnitNanocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanocelsius {
    fn default() -> Self {
        UnitNanocelsius
    }
}
impl Add<UnitNanocelsius> for UnitNanocelsius {
    type Output = UnitNanocelsius;
    #[inline]
    fn add(self, _: UnitNanocelsius) -> Self::Output {
        UnitNanocelsius
    }
}
impl AddAssign<UnitNanocelsius> for UnitNanocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitNanocelsius) {}
}
impl Sub<UnitNanocelsius> for UnitNanocelsius {
    type Output = UnitNanocelsius;
    #[inline]
    fn sub(self, _: UnitNanocelsius) -> Self::Output {
        UnitNanocelsius
    }
}
impl SubAssign<UnitNanocelsius> for UnitNanocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanocelsius) {}
}
pub struct UnitNanocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitNanocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitNanocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for isize {
    type Output = Quantity<isize, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for usize {
    type Output = Quantity<usize, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
impl Mul<UnitNanocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitNanocelsius>;
    fn mul(self, _: UnitNanocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitNanocelsius)
    }
}
pub struct UnitPicocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocelsius {
    #[inline]
    fn clone(&self) -> UnitPicocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocelsius {
    #[inline]
    fn eq(&self, other: &UnitPicocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicocelsius {
    fn default() -> Self {
        UnitPicocelsius
    }
}
impl Add<UnitPicocelsius> for UnitPicocelsius {
    type Output = UnitPicocelsius;
    #[inline]
    fn add(self, _: UnitPicocelsius) -> Self::Output {
        UnitPicocelsius
    }
}
impl AddAssign<UnitPicocelsius> for UnitPicocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitPicocelsius) {}
}
impl Sub<UnitPicocelsius> for UnitPicocelsius {
    type Output = UnitPicocelsius;
    #[inline]
    fn sub(self, _: UnitPicocelsius) -> Self::Output {
        UnitPicocelsius
    }
}
impl SubAssign<UnitPicocelsius> for UnitPicocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicocelsius) {}
}
pub struct UnitPicocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitPicocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitPicocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for isize {
    type Output = Quantity<isize, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for usize {
    type Output = Quantity<usize, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
impl Mul<UnitPicocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitPicocelsius>;
    fn mul(self, _: UnitPicocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitPicocelsius)
    }
}
pub struct UnitFemtocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocelsius {
    #[inline]
    fn clone(&self) -> UnitFemtocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocelsius {
    #[inline]
    fn eq(&self, other: &UnitFemtocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtocelsius {
    fn default() -> Self {
        UnitFemtocelsius
    }
}
impl Add<UnitFemtocelsius> for UnitFemtocelsius {
    type Output = UnitFemtocelsius;
    #[inline]
    fn add(self, _: UnitFemtocelsius) -> Self::Output {
        UnitFemtocelsius
    }
}
impl AddAssign<UnitFemtocelsius> for UnitFemtocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtocelsius) {}
}
impl Sub<UnitFemtocelsius> for UnitFemtocelsius {
    type Output = UnitFemtocelsius;
    #[inline]
    fn sub(self, _: UnitFemtocelsius) -> Self::Output {
        UnitFemtocelsius
    }
}
impl SubAssign<UnitFemtocelsius> for UnitFemtocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtocelsius) {}
}
pub struct UnitFemtocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitFemtocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitFemtocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for isize {
    type Output = Quantity<isize, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for usize {
    type Output = Quantity<usize, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
impl Mul<UnitFemtocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitFemtocelsius>;
    fn mul(self, _: UnitFemtocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitFemtocelsius)
    }
}
pub struct UnitAttocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocelsius {
    #[inline]
    fn clone(&self) -> UnitAttocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocelsius {
    #[inline]
    fn eq(&self, other: &UnitAttocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttocelsius {
    fn default() -> Self {
        UnitAttocelsius
    }
}
impl Add<UnitAttocelsius> for UnitAttocelsius {
    type Output = UnitAttocelsius;
    #[inline]
    fn add(self, _: UnitAttocelsius) -> Self::Output {
        UnitAttocelsius
    }
}
impl AddAssign<UnitAttocelsius> for UnitAttocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitAttocelsius) {}
}
impl Sub<UnitAttocelsius> for UnitAttocelsius {
    type Output = UnitAttocelsius;
    #[inline]
    fn sub(self, _: UnitAttocelsius) -> Self::Output {
        UnitAttocelsius
    }
}
impl SubAssign<UnitAttocelsius> for UnitAttocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttocelsius) {}
}
pub struct UnitAttocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitAttocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitAttocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for isize {
    type Output = Quantity<isize, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for usize {
    type Output = Quantity<usize, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
impl Mul<UnitAttocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitAttocelsius>;
    fn mul(self, _: UnitAttocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitAttocelsius)
    }
}
pub struct UnitZeptocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocelsius {
    #[inline]
    fn clone(&self) -> UnitZeptocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocelsius {
    #[inline]
    fn eq(&self, other: &UnitZeptocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptocelsius {
    fn default() -> Self {
        UnitZeptocelsius
    }
}
impl Add<UnitZeptocelsius> for UnitZeptocelsius {
    type Output = UnitZeptocelsius;
    #[inline]
    fn add(self, _: UnitZeptocelsius) -> Self::Output {
        UnitZeptocelsius
    }
}
impl AddAssign<UnitZeptocelsius> for UnitZeptocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptocelsius) {}
}
impl Sub<UnitZeptocelsius> for UnitZeptocelsius {
    type Output = UnitZeptocelsius;
    #[inline]
    fn sub(self, _: UnitZeptocelsius) -> Self::Output {
        UnitZeptocelsius
    }
}
impl SubAssign<UnitZeptocelsius> for UnitZeptocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptocelsius) {}
}
pub struct UnitZeptocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitZeptocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitZeptocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for isize {
    type Output = Quantity<isize, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for usize {
    type Output = Quantity<usize, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
impl Mul<UnitZeptocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitZeptocelsius>;
    fn mul(self, _: UnitZeptocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitZeptocelsius)
    }
}
pub struct UnitYoctocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocelsius {
    #[inline]
    fn clone(&self) -> UnitYoctocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocelsius {
    #[inline]
    fn eq(&self, other: &UnitYoctocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctocelsius {
    fn default() -> Self {
        UnitYoctocelsius
    }
}
impl Add<UnitYoctocelsius> for UnitYoctocelsius {
    type Output = UnitYoctocelsius;
    #[inline]
    fn add(self, _: UnitYoctocelsius) -> Self::Output {
        UnitYoctocelsius
    }
}
impl AddAssign<UnitYoctocelsius> for UnitYoctocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctocelsius) {}
}
impl Sub<UnitYoctocelsius> for UnitYoctocelsius {
    type Output = UnitYoctocelsius;
    #[inline]
    fn sub(self, _: UnitYoctocelsius) -> Self::Output {
        UnitYoctocelsius
    }
}
impl SubAssign<UnitYoctocelsius> for UnitYoctocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctocelsius) {}
}
pub struct UnitYoctocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitYoctocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitYoctocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for isize {
    type Output = Quantity<isize, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for usize {
    type Output = Quantity<usize, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
impl Mul<UnitYoctocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitYoctocelsius>;
    fn mul(self, _: UnitYoctocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitYoctocelsius)
    }
}
pub struct UnitRontocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocelsius {
    #[inline]
    fn clone(&self) -> UnitRontocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocelsius {
    #[inline]
    fn eq(&self, other: &UnitRontocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontocelsius {
    fn default() -> Self {
        UnitRontocelsius
    }
}
impl Add<UnitRontocelsius> for UnitRontocelsius {
    type Output = UnitRontocelsius;
    #[inline]
    fn add(self, _: UnitRontocelsius) -> Self::Output {
        UnitRontocelsius
    }
}
impl AddAssign<UnitRontocelsius> for UnitRontocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitRontocelsius) {}
}
impl Sub<UnitRontocelsius> for UnitRontocelsius {
    type Output = UnitRontocelsius;
    #[inline]
    fn sub(self, _: UnitRontocelsius) -> Self::Output {
        UnitRontocelsius
    }
}
impl SubAssign<UnitRontocelsius> for UnitRontocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontocelsius) {}
}
pub struct UnitRontocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitRontocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitRontocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for isize {
    type Output = Quantity<isize, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for usize {
    type Output = Quantity<usize, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
impl Mul<UnitRontocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitRontocelsius>;
    fn mul(self, _: UnitRontocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitRontocelsius)
    }
}
pub struct UnitQuectocelsius;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocelsius {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocelsius")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocelsius {
    #[inline]
    fn clone(&self) -> UnitQuectocelsius {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocelsius {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocelsius {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocelsius {
    #[inline]
    fn eq(&self, other: &UnitQuectocelsius) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocelsius {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectocelsius {
    fn default() -> Self {
        UnitQuectocelsius
    }
}
impl Add<UnitQuectocelsius> for UnitQuectocelsius {
    type Output = UnitQuectocelsius;
    #[inline]
    fn add(self, _: UnitQuectocelsius) -> Self::Output {
        UnitQuectocelsius
    }
}
impl AddAssign<UnitQuectocelsius> for UnitQuectocelsius {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectocelsius) {}
}
impl Sub<UnitQuectocelsius> for UnitQuectocelsius {
    type Output = UnitQuectocelsius;
    #[inline]
    fn sub(self, _: UnitQuectocelsius) -> Self::Output {
        UnitQuectocelsius
    }
}
impl SubAssign<UnitQuectocelsius> for UnitQuectocelsius {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectocelsius) {}
}
pub struct UnitQuectocelsiusMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectocelsiusMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectocelsiusMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectocelsiusMul {
    #[inline]
    fn clone(&self) -> UnitQuectocelsiusMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectocelsiusMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectocelsiusMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectocelsiusMul {
    #[inline]
    fn eq(&self, other: &UnitQuectocelsiusMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectocelsiusMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectocelsiusMul> for i8 {
    type Output = Quantity<i8, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for i16 {
    type Output = Quantity<i16, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for i32 {
    type Output = Quantity<i32, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for i64 {
    type Output = Quantity<i64, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for i128 {
    type Output = Quantity<i128, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for isize {
    type Output = Quantity<isize, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for u8 {
    type Output = Quantity<u8, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for u16 {
    type Output = Quantity<u16, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for u32 {
    type Output = Quantity<u32, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for u64 {
    type Output = Quantity<u64, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for u128 {
    type Output = Quantity<u128, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for usize {
    type Output = Quantity<usize, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for f32 {
    type Output = Quantity<f32, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
impl Mul<UnitQuectocelsiusMul> for f64 {
    type Output = Quantity<f64, UnitQuectocelsius>;
    fn mul(self, _: UnitQuectocelsiusMul) -> Self::Output {
        Quantity::new(self, UnitQuectocelsius)
    }
}
pub type Celsius<T> = Quantity<T, UnitCelsius>;
#[allow(non_upper_case_globals)]
pub static Celsius: UnitCelsiusMul = UnitCelsiusMul;
pub type Quettacelsius<T> = Quantity<T, UnitQuettacelsius>;
#[allow(non_upper_case_globals)]
pub static Quettacelsius: UnitQuettacelsiusMul = UnitQuettacelsiusMul;
pub type Ronnacelsius<T> = Quantity<T, UnitRonnacelsius>;
#[allow(non_upper_case_globals)]
pub static Ronnacelsius: UnitRonnacelsiusMul = UnitRonnacelsiusMul;
pub type Yottacelsius<T> = Quantity<T, UnitYottacelsius>;
#[allow(non_upper_case_globals)]
pub static Yottacelsius: UnitYottacelsiusMul = UnitYottacelsiusMul;
pub type Zettacelsius<T> = Quantity<T, UnitZettacelsius>;
#[allow(non_upper_case_globals)]
pub static Zettacelsius: UnitZettacelsiusMul = UnitZettacelsiusMul;
pub type Exacelsius<T> = Quantity<T, UnitExacelsius>;
#[allow(non_upper_case_globals)]
pub static Exacelsius: UnitExacelsiusMul = UnitExacelsiusMul;
pub type Petacelsius<T> = Quantity<T, UnitPetacelsius>;
#[allow(non_upper_case_globals)]
pub static Petacelsius: UnitPetacelsiusMul = UnitPetacelsiusMul;
pub type Teracelsius<T> = Quantity<T, UnitTeracelsius>;
#[allow(non_upper_case_globals)]
pub static Teracelsius: UnitTeracelsiusMul = UnitTeracelsiusMul;
pub type Gigacelsius<T> = Quantity<T, UnitGigacelsius>;
#[allow(non_upper_case_globals)]
pub static Gigacelsius: UnitGigacelsiusMul = UnitGigacelsiusMul;
pub type Megacelsius<T> = Quantity<T, UnitMegacelsius>;
#[allow(non_upper_case_globals)]
pub static Megacelsius: UnitMegacelsiusMul = UnitMegacelsiusMul;
pub type Kilocelsius<T> = Quantity<T, UnitKilocelsius>;
#[allow(non_upper_case_globals)]
pub static Kilocelsius: UnitKilocelsiusMul = UnitKilocelsiusMul;
pub type Hectocelsius<T> = Quantity<T, UnitHectocelsius>;
#[allow(non_upper_case_globals)]
pub static Hectocelsius: UnitHectocelsiusMul = UnitHectocelsiusMul;
pub type Decacelsius<T> = Quantity<T, UnitDecacelsius>;
#[allow(non_upper_case_globals)]
pub static Decacelsius: UnitDecacelsiusMul = UnitDecacelsiusMul;
pub type Decicelsius<T> = Quantity<T, UnitDecicelsius>;
#[allow(non_upper_case_globals)]
pub static Decicelsius: UnitDecicelsiusMul = UnitDecicelsiusMul;
pub type Centicelsius<T> = Quantity<T, UnitCenticelsius>;
#[allow(non_upper_case_globals)]
pub static Centicelsius: UnitCenticelsiusMul = UnitCenticelsiusMul;
pub type Millicelsius<T> = Quantity<T, UnitMillicelsius>;
#[allow(non_upper_case_globals)]
pub static Millicelsius: UnitMillicelsiusMul = UnitMillicelsiusMul;
pub type Microcelsius<T> = Quantity<T, UnitMicrocelsius>;
#[allow(non_upper_case_globals)]
pub static Microcelsius: UnitMicrocelsiusMul = UnitMicrocelsiusMul;
pub type Nanocelsius<T> = Quantity<T, UnitNanocelsius>;
#[allow(non_upper_case_globals)]
pub static Nanocelsius: UnitNanocelsiusMul = UnitNanocelsiusMul;
pub type Picocelsius<T> = Quantity<T, UnitPicocelsius>;
#[allow(non_upper_case_globals)]
pub static Picocelsius: UnitPicocelsiusMul = UnitPicocelsiusMul;
pub type Femtocelsius<T> = Quantity<T, UnitFemtocelsius>;
#[allow(non_upper_case_globals)]
pub static Femtocelsius: UnitFemtocelsiusMul = UnitFemtocelsiusMul;
pub type Attocelsius<T> = Quantity<T, UnitAttocelsius>;
#[allow(non_upper_case_globals)]
pub static Attocelsius: UnitAttocelsiusMul = UnitAttocelsiusMul;
pub type Zeptocelsius<T> = Quantity<T, UnitZeptocelsius>;
#[allow(non_upper_case_globals)]
pub static Zeptocelsius: UnitZeptocelsiusMul = UnitZeptocelsiusMul;
pub type Yoctocelsius<T> = Quantity<T, UnitYoctocelsius>;
#[allow(non_upper_case_globals)]
pub static Yoctocelsius: UnitYoctocelsiusMul = UnitYoctocelsiusMul;
pub type Rontocelsius<T> = Quantity<T, UnitRontocelsius>;
#[allow(non_upper_case_globals)]
pub static Rontocelsius: UnitRontocelsiusMul = UnitRontocelsiusMul;
pub type Quectocelsius<T> = Quantity<T, UnitQuectocelsius>;
#[allow(non_upper_case_globals)]
pub static Quectocelsius: UnitQuectocelsiusMul = UnitQuectocelsiusMul;
pub struct UnitLumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitLumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitLumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitLumens {
    #[inline]
    fn clone(&self) -> UnitLumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitLumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitLumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitLumens {
    #[inline]
    fn eq(&self, other: &UnitLumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitLumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitLumens {
    fn default() -> Self {
        UnitLumens
    }
}
impl Add<UnitLumens> for UnitLumens {
    type Output = UnitLumens;
    #[inline]
    fn add(self, _: UnitLumens) -> Self::Output {
        UnitLumens
    }
}
impl AddAssign<UnitLumens> for UnitLumens {
    #[inline]
    fn add_assign(&mut self, _: UnitLumens) {}
}
impl Sub<UnitLumens> for UnitLumens {
    type Output = UnitLumens;
    #[inline]
    fn sub(self, _: UnitLumens) -> Self::Output {
        UnitLumens
    }
}
impl SubAssign<UnitLumens> for UnitLumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitLumens) {}
}
pub struct UnitLumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitLumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitLumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitLumensMul {
    #[inline]
    fn clone(&self) -> UnitLumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitLumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitLumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitLumensMul {
    #[inline]
    fn eq(&self, other: &UnitLumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitLumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitLumensMul> for i8 {
    type Output = Quantity<i8, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for i16 {
    type Output = Quantity<i16, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for i32 {
    type Output = Quantity<i32, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for i64 {
    type Output = Quantity<i64, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for i128 {
    type Output = Quantity<i128, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for isize {
    type Output = Quantity<isize, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for u8 {
    type Output = Quantity<u8, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for u16 {
    type Output = Quantity<u16, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for u32 {
    type Output = Quantity<u32, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for u64 {
    type Output = Quantity<u64, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for u128 {
    type Output = Quantity<u128, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for usize {
    type Output = Quantity<usize, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for f32 {
    type Output = Quantity<f32, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
impl Mul<UnitLumensMul> for f64 {
    type Output = Quantity<f64, UnitLumens>;
    fn mul(self, _: UnitLumensMul) -> Self::Output {
        Quantity::new(self, UnitLumens)
    }
}
pub struct UnitQuettalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettalumens {
    #[inline]
    fn clone(&self) -> UnitQuettalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettalumens {
    #[inline]
    fn eq(&self, other: &UnitQuettalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettalumens {
    fn default() -> Self {
        UnitQuettalumens
    }
}
impl Add<UnitQuettalumens> for UnitQuettalumens {
    type Output = UnitQuettalumens;
    #[inline]
    fn add(self, _: UnitQuettalumens) -> Self::Output {
        UnitQuettalumens
    }
}
impl AddAssign<UnitQuettalumens> for UnitQuettalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettalumens) {}
}
impl Sub<UnitQuettalumens> for UnitQuettalumens {
    type Output = UnitQuettalumens;
    #[inline]
    fn sub(self, _: UnitQuettalumens) -> Self::Output {
        UnitQuettalumens
    }
}
impl SubAssign<UnitQuettalumens> for UnitQuettalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettalumens) {}
}
pub struct UnitQuettalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettalumensMul {
    #[inline]
    fn clone(&self) -> UnitQuettalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettalumensMul {
    #[inline]
    fn eq(&self, other: &UnitQuettalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettalumensMul> for i8 {
    type Output = Quantity<i8, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for i16 {
    type Output = Quantity<i16, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for i32 {
    type Output = Quantity<i32, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for i64 {
    type Output = Quantity<i64, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for i128 {
    type Output = Quantity<i128, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for isize {
    type Output = Quantity<isize, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for u8 {
    type Output = Quantity<u8, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for u16 {
    type Output = Quantity<u16, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for u32 {
    type Output = Quantity<u32, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for u64 {
    type Output = Quantity<u64, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for u128 {
    type Output = Quantity<u128, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for usize {
    type Output = Quantity<usize, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for f32 {
    type Output = Quantity<f32, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
impl Mul<UnitQuettalumensMul> for f64 {
    type Output = Quantity<f64, UnitQuettalumens>;
    fn mul(self, _: UnitQuettalumensMul) -> Self::Output {
        Quantity::new(self, UnitQuettalumens)
    }
}
pub struct UnitRonnalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnalumens {
    #[inline]
    fn clone(&self) -> UnitRonnalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnalumens {
    #[inline]
    fn eq(&self, other: &UnitRonnalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnalumens {
    fn default() -> Self {
        UnitRonnalumens
    }
}
impl Add<UnitRonnalumens> for UnitRonnalumens {
    type Output = UnitRonnalumens;
    #[inline]
    fn add(self, _: UnitRonnalumens) -> Self::Output {
        UnitRonnalumens
    }
}
impl AddAssign<UnitRonnalumens> for UnitRonnalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnalumens) {}
}
impl Sub<UnitRonnalumens> for UnitRonnalumens {
    type Output = UnitRonnalumens;
    #[inline]
    fn sub(self, _: UnitRonnalumens) -> Self::Output {
        UnitRonnalumens
    }
}
impl SubAssign<UnitRonnalumens> for UnitRonnalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnalumens) {}
}
pub struct UnitRonnalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnalumensMul {
    #[inline]
    fn clone(&self) -> UnitRonnalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnalumensMul {
    #[inline]
    fn eq(&self, other: &UnitRonnalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnalumensMul> for i8 {
    type Output = Quantity<i8, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for i16 {
    type Output = Quantity<i16, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for i32 {
    type Output = Quantity<i32, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for i64 {
    type Output = Quantity<i64, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for i128 {
    type Output = Quantity<i128, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for isize {
    type Output = Quantity<isize, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for u8 {
    type Output = Quantity<u8, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for u16 {
    type Output = Quantity<u16, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for u32 {
    type Output = Quantity<u32, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for u64 {
    type Output = Quantity<u64, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for u128 {
    type Output = Quantity<u128, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for usize {
    type Output = Quantity<usize, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for f32 {
    type Output = Quantity<f32, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
impl Mul<UnitRonnalumensMul> for f64 {
    type Output = Quantity<f64, UnitRonnalumens>;
    fn mul(self, _: UnitRonnalumensMul) -> Self::Output {
        Quantity::new(self, UnitRonnalumens)
    }
}
pub struct UnitYottalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottalumens {
    #[inline]
    fn clone(&self) -> UnitYottalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottalumens {
    #[inline]
    fn eq(&self, other: &UnitYottalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottalumens {
    fn default() -> Self {
        UnitYottalumens
    }
}
impl Add<UnitYottalumens> for UnitYottalumens {
    type Output = UnitYottalumens;
    #[inline]
    fn add(self, _: UnitYottalumens) -> Self::Output {
        UnitYottalumens
    }
}
impl AddAssign<UnitYottalumens> for UnitYottalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitYottalumens) {}
}
impl Sub<UnitYottalumens> for UnitYottalumens {
    type Output = UnitYottalumens;
    #[inline]
    fn sub(self, _: UnitYottalumens) -> Self::Output {
        UnitYottalumens
    }
}
impl SubAssign<UnitYottalumens> for UnitYottalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottalumens) {}
}
pub struct UnitYottalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottalumensMul {
    #[inline]
    fn clone(&self) -> UnitYottalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottalumensMul {
    #[inline]
    fn eq(&self, other: &UnitYottalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottalumensMul> for i8 {
    type Output = Quantity<i8, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for i16 {
    type Output = Quantity<i16, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for i32 {
    type Output = Quantity<i32, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for i64 {
    type Output = Quantity<i64, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for i128 {
    type Output = Quantity<i128, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for isize {
    type Output = Quantity<isize, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for u8 {
    type Output = Quantity<u8, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for u16 {
    type Output = Quantity<u16, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for u32 {
    type Output = Quantity<u32, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for u64 {
    type Output = Quantity<u64, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for u128 {
    type Output = Quantity<u128, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for usize {
    type Output = Quantity<usize, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for f32 {
    type Output = Quantity<f32, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
impl Mul<UnitYottalumensMul> for f64 {
    type Output = Quantity<f64, UnitYottalumens>;
    fn mul(self, _: UnitYottalumensMul) -> Self::Output {
        Quantity::new(self, UnitYottalumens)
    }
}
pub struct UnitZettalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettalumens {
    #[inline]
    fn clone(&self) -> UnitZettalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettalumens {
    #[inline]
    fn eq(&self, other: &UnitZettalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettalumens {
    fn default() -> Self {
        UnitZettalumens
    }
}
impl Add<UnitZettalumens> for UnitZettalumens {
    type Output = UnitZettalumens;
    #[inline]
    fn add(self, _: UnitZettalumens) -> Self::Output {
        UnitZettalumens
    }
}
impl AddAssign<UnitZettalumens> for UnitZettalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitZettalumens) {}
}
impl Sub<UnitZettalumens> for UnitZettalumens {
    type Output = UnitZettalumens;
    #[inline]
    fn sub(self, _: UnitZettalumens) -> Self::Output {
        UnitZettalumens
    }
}
impl SubAssign<UnitZettalumens> for UnitZettalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettalumens) {}
}
pub struct UnitZettalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettalumensMul {
    #[inline]
    fn clone(&self) -> UnitZettalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettalumensMul {
    #[inline]
    fn eq(&self, other: &UnitZettalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettalumensMul> for i8 {
    type Output = Quantity<i8, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for i16 {
    type Output = Quantity<i16, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for i32 {
    type Output = Quantity<i32, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for i64 {
    type Output = Quantity<i64, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for i128 {
    type Output = Quantity<i128, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for isize {
    type Output = Quantity<isize, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for u8 {
    type Output = Quantity<u8, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for u16 {
    type Output = Quantity<u16, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for u32 {
    type Output = Quantity<u32, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for u64 {
    type Output = Quantity<u64, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for u128 {
    type Output = Quantity<u128, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for usize {
    type Output = Quantity<usize, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for f32 {
    type Output = Quantity<f32, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
impl Mul<UnitZettalumensMul> for f64 {
    type Output = Quantity<f64, UnitZettalumens>;
    fn mul(self, _: UnitZettalumensMul) -> Self::Output {
        Quantity::new(self, UnitZettalumens)
    }
}
pub struct UnitExalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExalumens {
    #[inline]
    fn clone(&self) -> UnitExalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExalumens {
    #[inline]
    fn eq(&self, other: &UnitExalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExalumens {
    fn default() -> Self {
        UnitExalumens
    }
}
impl Add<UnitExalumens> for UnitExalumens {
    type Output = UnitExalumens;
    #[inline]
    fn add(self, _: UnitExalumens) -> Self::Output {
        UnitExalumens
    }
}
impl AddAssign<UnitExalumens> for UnitExalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitExalumens) {}
}
impl Sub<UnitExalumens> for UnitExalumens {
    type Output = UnitExalumens;
    #[inline]
    fn sub(self, _: UnitExalumens) -> Self::Output {
        UnitExalumens
    }
}
impl SubAssign<UnitExalumens> for UnitExalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitExalumens) {}
}
pub struct UnitExalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExalumensMul {
    #[inline]
    fn clone(&self) -> UnitExalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExalumensMul {
    #[inline]
    fn eq(&self, other: &UnitExalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExalumensMul> for i8 {
    type Output = Quantity<i8, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for i16 {
    type Output = Quantity<i16, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for i32 {
    type Output = Quantity<i32, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for i64 {
    type Output = Quantity<i64, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for i128 {
    type Output = Quantity<i128, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for isize {
    type Output = Quantity<isize, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for u8 {
    type Output = Quantity<u8, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for u16 {
    type Output = Quantity<u16, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for u32 {
    type Output = Quantity<u32, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for u64 {
    type Output = Quantity<u64, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for u128 {
    type Output = Quantity<u128, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for usize {
    type Output = Quantity<usize, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for f32 {
    type Output = Quantity<f32, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
impl Mul<UnitExalumensMul> for f64 {
    type Output = Quantity<f64, UnitExalumens>;
    fn mul(self, _: UnitExalumensMul) -> Self::Output {
        Quantity::new(self, UnitExalumens)
    }
}
pub struct UnitPetalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetalumens {
    #[inline]
    fn clone(&self) -> UnitPetalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetalumens {
    #[inline]
    fn eq(&self, other: &UnitPetalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetalumens {
    fn default() -> Self {
        UnitPetalumens
    }
}
impl Add<UnitPetalumens> for UnitPetalumens {
    type Output = UnitPetalumens;
    #[inline]
    fn add(self, _: UnitPetalumens) -> Self::Output {
        UnitPetalumens
    }
}
impl AddAssign<UnitPetalumens> for UnitPetalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitPetalumens) {}
}
impl Sub<UnitPetalumens> for UnitPetalumens {
    type Output = UnitPetalumens;
    #[inline]
    fn sub(self, _: UnitPetalumens) -> Self::Output {
        UnitPetalumens
    }
}
impl SubAssign<UnitPetalumens> for UnitPetalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetalumens) {}
}
pub struct UnitPetalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetalumensMul {
    #[inline]
    fn clone(&self) -> UnitPetalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetalumensMul {
    #[inline]
    fn eq(&self, other: &UnitPetalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetalumensMul> for i8 {
    type Output = Quantity<i8, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for i16 {
    type Output = Quantity<i16, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for i32 {
    type Output = Quantity<i32, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for i64 {
    type Output = Quantity<i64, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for i128 {
    type Output = Quantity<i128, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for isize {
    type Output = Quantity<isize, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for u8 {
    type Output = Quantity<u8, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for u16 {
    type Output = Quantity<u16, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for u32 {
    type Output = Quantity<u32, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for u64 {
    type Output = Quantity<u64, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for u128 {
    type Output = Quantity<u128, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for usize {
    type Output = Quantity<usize, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for f32 {
    type Output = Quantity<f32, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
impl Mul<UnitPetalumensMul> for f64 {
    type Output = Quantity<f64, UnitPetalumens>;
    fn mul(self, _: UnitPetalumensMul) -> Self::Output {
        Quantity::new(self, UnitPetalumens)
    }
}
pub struct UnitTeralumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeralumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeralumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeralumens {
    #[inline]
    fn clone(&self) -> UnitTeralumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeralumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeralumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeralumens {
    #[inline]
    fn eq(&self, other: &UnitTeralumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeralumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeralumens {
    fn default() -> Self {
        UnitTeralumens
    }
}
impl Add<UnitTeralumens> for UnitTeralumens {
    type Output = UnitTeralumens;
    #[inline]
    fn add(self, _: UnitTeralumens) -> Self::Output {
        UnitTeralumens
    }
}
impl AddAssign<UnitTeralumens> for UnitTeralumens {
    #[inline]
    fn add_assign(&mut self, _: UnitTeralumens) {}
}
impl Sub<UnitTeralumens> for UnitTeralumens {
    type Output = UnitTeralumens;
    #[inline]
    fn sub(self, _: UnitTeralumens) -> Self::Output {
        UnitTeralumens
    }
}
impl SubAssign<UnitTeralumens> for UnitTeralumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeralumens) {}
}
pub struct UnitTeralumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeralumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeralumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeralumensMul {
    #[inline]
    fn clone(&self) -> UnitTeralumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeralumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeralumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeralumensMul {
    #[inline]
    fn eq(&self, other: &UnitTeralumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeralumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeralumensMul> for i8 {
    type Output = Quantity<i8, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for i16 {
    type Output = Quantity<i16, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for i32 {
    type Output = Quantity<i32, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for i64 {
    type Output = Quantity<i64, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for i128 {
    type Output = Quantity<i128, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for isize {
    type Output = Quantity<isize, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for u8 {
    type Output = Quantity<u8, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for u16 {
    type Output = Quantity<u16, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for u32 {
    type Output = Quantity<u32, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for u64 {
    type Output = Quantity<u64, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for u128 {
    type Output = Quantity<u128, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for usize {
    type Output = Quantity<usize, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for f32 {
    type Output = Quantity<f32, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
impl Mul<UnitTeralumensMul> for f64 {
    type Output = Quantity<f64, UnitTeralumens>;
    fn mul(self, _: UnitTeralumensMul) -> Self::Output {
        Quantity::new(self, UnitTeralumens)
    }
}
pub struct UnitGigalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigalumens {
    #[inline]
    fn clone(&self) -> UnitGigalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigalumens {
    #[inline]
    fn eq(&self, other: &UnitGigalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigalumens {
    fn default() -> Self {
        UnitGigalumens
    }
}
impl Add<UnitGigalumens> for UnitGigalumens {
    type Output = UnitGigalumens;
    #[inline]
    fn add(self, _: UnitGigalumens) -> Self::Output {
        UnitGigalumens
    }
}
impl AddAssign<UnitGigalumens> for UnitGigalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitGigalumens) {}
}
impl Sub<UnitGigalumens> for UnitGigalumens {
    type Output = UnitGigalumens;
    #[inline]
    fn sub(self, _: UnitGigalumens) -> Self::Output {
        UnitGigalumens
    }
}
impl SubAssign<UnitGigalumens> for UnitGigalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigalumens) {}
}
pub struct UnitGigalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigalumensMul {
    #[inline]
    fn clone(&self) -> UnitGigalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigalumensMul {
    #[inline]
    fn eq(&self, other: &UnitGigalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigalumensMul> for i8 {
    type Output = Quantity<i8, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for i16 {
    type Output = Quantity<i16, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for i32 {
    type Output = Quantity<i32, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for i64 {
    type Output = Quantity<i64, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for i128 {
    type Output = Quantity<i128, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for isize {
    type Output = Quantity<isize, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for u8 {
    type Output = Quantity<u8, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for u16 {
    type Output = Quantity<u16, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for u32 {
    type Output = Quantity<u32, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for u64 {
    type Output = Quantity<u64, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for u128 {
    type Output = Quantity<u128, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for usize {
    type Output = Quantity<usize, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for f32 {
    type Output = Quantity<f32, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
impl Mul<UnitGigalumensMul> for f64 {
    type Output = Quantity<f64, UnitGigalumens>;
    fn mul(self, _: UnitGigalumensMul) -> Self::Output {
        Quantity::new(self, UnitGigalumens)
    }
}
pub struct UnitMegalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegalumens {
    #[inline]
    fn clone(&self) -> UnitMegalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegalumens {
    #[inline]
    fn eq(&self, other: &UnitMegalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegalumens {
    fn default() -> Self {
        UnitMegalumens
    }
}
impl Add<UnitMegalumens> for UnitMegalumens {
    type Output = UnitMegalumens;
    #[inline]
    fn add(self, _: UnitMegalumens) -> Self::Output {
        UnitMegalumens
    }
}
impl AddAssign<UnitMegalumens> for UnitMegalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitMegalumens) {}
}
impl Sub<UnitMegalumens> for UnitMegalumens {
    type Output = UnitMegalumens;
    #[inline]
    fn sub(self, _: UnitMegalumens) -> Self::Output {
        UnitMegalumens
    }
}
impl SubAssign<UnitMegalumens> for UnitMegalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegalumens) {}
}
pub struct UnitMegalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegalumensMul {
    #[inline]
    fn clone(&self) -> UnitMegalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegalumensMul {
    #[inline]
    fn eq(&self, other: &UnitMegalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegalumensMul> for i8 {
    type Output = Quantity<i8, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for i16 {
    type Output = Quantity<i16, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for i32 {
    type Output = Quantity<i32, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for i64 {
    type Output = Quantity<i64, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for i128 {
    type Output = Quantity<i128, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for isize {
    type Output = Quantity<isize, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for u8 {
    type Output = Quantity<u8, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for u16 {
    type Output = Quantity<u16, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for u32 {
    type Output = Quantity<u32, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for u64 {
    type Output = Quantity<u64, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for u128 {
    type Output = Quantity<u128, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for usize {
    type Output = Quantity<usize, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for f32 {
    type Output = Quantity<f32, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
impl Mul<UnitMegalumensMul> for f64 {
    type Output = Quantity<f64, UnitMegalumens>;
    fn mul(self, _: UnitMegalumensMul) -> Self::Output {
        Quantity::new(self, UnitMegalumens)
    }
}
pub struct UnitKilolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilolumens {
    #[inline]
    fn clone(&self) -> UnitKilolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilolumens {
    #[inline]
    fn eq(&self, other: &UnitKilolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilolumens {
    fn default() -> Self {
        UnitKilolumens
    }
}
impl Add<UnitKilolumens> for UnitKilolumens {
    type Output = UnitKilolumens;
    #[inline]
    fn add(self, _: UnitKilolumens) -> Self::Output {
        UnitKilolumens
    }
}
impl AddAssign<UnitKilolumens> for UnitKilolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitKilolumens) {}
}
impl Sub<UnitKilolumens> for UnitKilolumens {
    type Output = UnitKilolumens;
    #[inline]
    fn sub(self, _: UnitKilolumens) -> Self::Output {
        UnitKilolumens
    }
}
impl SubAssign<UnitKilolumens> for UnitKilolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilolumens) {}
}
pub struct UnitKilolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilolumensMul {
    #[inline]
    fn clone(&self) -> UnitKilolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilolumensMul {
    #[inline]
    fn eq(&self, other: &UnitKilolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilolumensMul> for i8 {
    type Output = Quantity<i8, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for i16 {
    type Output = Quantity<i16, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for i32 {
    type Output = Quantity<i32, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for i64 {
    type Output = Quantity<i64, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for i128 {
    type Output = Quantity<i128, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for isize {
    type Output = Quantity<isize, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for u8 {
    type Output = Quantity<u8, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for u16 {
    type Output = Quantity<u16, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for u32 {
    type Output = Quantity<u32, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for u64 {
    type Output = Quantity<u64, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for u128 {
    type Output = Quantity<u128, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for usize {
    type Output = Quantity<usize, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for f32 {
    type Output = Quantity<f32, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
impl Mul<UnitKilolumensMul> for f64 {
    type Output = Quantity<f64, UnitKilolumens>;
    fn mul(self, _: UnitKilolumensMul) -> Self::Output {
        Quantity::new(self, UnitKilolumens)
    }
}
pub struct UnitHectolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectolumens {
    #[inline]
    fn clone(&self) -> UnitHectolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectolumens {
    #[inline]
    fn eq(&self, other: &UnitHectolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectolumens {
    fn default() -> Self {
        UnitHectolumens
    }
}
impl Add<UnitHectolumens> for UnitHectolumens {
    type Output = UnitHectolumens;
    #[inline]
    fn add(self, _: UnitHectolumens) -> Self::Output {
        UnitHectolumens
    }
}
impl AddAssign<UnitHectolumens> for UnitHectolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitHectolumens) {}
}
impl Sub<UnitHectolumens> for UnitHectolumens {
    type Output = UnitHectolumens;
    #[inline]
    fn sub(self, _: UnitHectolumens) -> Self::Output {
        UnitHectolumens
    }
}
impl SubAssign<UnitHectolumens> for UnitHectolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectolumens) {}
}
pub struct UnitHectolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectolumensMul {
    #[inline]
    fn clone(&self) -> UnitHectolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectolumensMul {
    #[inline]
    fn eq(&self, other: &UnitHectolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectolumensMul> for i8 {
    type Output = Quantity<i8, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for i16 {
    type Output = Quantity<i16, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for i32 {
    type Output = Quantity<i32, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for i64 {
    type Output = Quantity<i64, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for i128 {
    type Output = Quantity<i128, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for isize {
    type Output = Quantity<isize, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for u8 {
    type Output = Quantity<u8, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for u16 {
    type Output = Quantity<u16, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for u32 {
    type Output = Quantity<u32, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for u64 {
    type Output = Quantity<u64, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for u128 {
    type Output = Quantity<u128, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for usize {
    type Output = Quantity<usize, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for f32 {
    type Output = Quantity<f32, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
impl Mul<UnitHectolumensMul> for f64 {
    type Output = Quantity<f64, UnitHectolumens>;
    fn mul(self, _: UnitHectolumensMul) -> Self::Output {
        Quantity::new(self, UnitHectolumens)
    }
}
pub struct UnitDecalumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecalumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecalumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecalumens {
    #[inline]
    fn clone(&self) -> UnitDecalumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecalumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecalumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecalumens {
    #[inline]
    fn eq(&self, other: &UnitDecalumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecalumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecalumens {
    fn default() -> Self {
        UnitDecalumens
    }
}
impl Add<UnitDecalumens> for UnitDecalumens {
    type Output = UnitDecalumens;
    #[inline]
    fn add(self, _: UnitDecalumens) -> Self::Output {
        UnitDecalumens
    }
}
impl AddAssign<UnitDecalumens> for UnitDecalumens {
    #[inline]
    fn add_assign(&mut self, _: UnitDecalumens) {}
}
impl Sub<UnitDecalumens> for UnitDecalumens {
    type Output = UnitDecalumens;
    #[inline]
    fn sub(self, _: UnitDecalumens) -> Self::Output {
        UnitDecalumens
    }
}
impl SubAssign<UnitDecalumens> for UnitDecalumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecalumens) {}
}
pub struct UnitDecalumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecalumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecalumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecalumensMul {
    #[inline]
    fn clone(&self) -> UnitDecalumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecalumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecalumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecalumensMul {
    #[inline]
    fn eq(&self, other: &UnitDecalumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecalumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecalumensMul> for i8 {
    type Output = Quantity<i8, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for i16 {
    type Output = Quantity<i16, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for i32 {
    type Output = Quantity<i32, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for i64 {
    type Output = Quantity<i64, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for i128 {
    type Output = Quantity<i128, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for isize {
    type Output = Quantity<isize, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for u8 {
    type Output = Quantity<u8, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for u16 {
    type Output = Quantity<u16, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for u32 {
    type Output = Quantity<u32, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for u64 {
    type Output = Quantity<u64, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for u128 {
    type Output = Quantity<u128, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for usize {
    type Output = Quantity<usize, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for f32 {
    type Output = Quantity<f32, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
impl Mul<UnitDecalumensMul> for f64 {
    type Output = Quantity<f64, UnitDecalumens>;
    fn mul(self, _: UnitDecalumensMul) -> Self::Output {
        Quantity::new(self, UnitDecalumens)
    }
}
pub struct UnitDecilumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecilumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecilumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecilumens {
    #[inline]
    fn clone(&self) -> UnitDecilumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecilumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecilumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecilumens {
    #[inline]
    fn eq(&self, other: &UnitDecilumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecilumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecilumens {
    fn default() -> Self {
        UnitDecilumens
    }
}
impl Add<UnitDecilumens> for UnitDecilumens {
    type Output = UnitDecilumens;
    #[inline]
    fn add(self, _: UnitDecilumens) -> Self::Output {
        UnitDecilumens
    }
}
impl AddAssign<UnitDecilumens> for UnitDecilumens {
    #[inline]
    fn add_assign(&mut self, _: UnitDecilumens) {}
}
impl Sub<UnitDecilumens> for UnitDecilumens {
    type Output = UnitDecilumens;
    #[inline]
    fn sub(self, _: UnitDecilumens) -> Self::Output {
        UnitDecilumens
    }
}
impl SubAssign<UnitDecilumens> for UnitDecilumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecilumens) {}
}
pub struct UnitDecilumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecilumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecilumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecilumensMul {
    #[inline]
    fn clone(&self) -> UnitDecilumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecilumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecilumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecilumensMul {
    #[inline]
    fn eq(&self, other: &UnitDecilumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecilumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecilumensMul> for i8 {
    type Output = Quantity<i8, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for i16 {
    type Output = Quantity<i16, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for i32 {
    type Output = Quantity<i32, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for i64 {
    type Output = Quantity<i64, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for i128 {
    type Output = Quantity<i128, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for isize {
    type Output = Quantity<isize, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for u8 {
    type Output = Quantity<u8, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for u16 {
    type Output = Quantity<u16, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for u32 {
    type Output = Quantity<u32, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for u64 {
    type Output = Quantity<u64, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for u128 {
    type Output = Quantity<u128, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for usize {
    type Output = Quantity<usize, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for f32 {
    type Output = Quantity<f32, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
impl Mul<UnitDecilumensMul> for f64 {
    type Output = Quantity<f64, UnitDecilumens>;
    fn mul(self, _: UnitDecilumensMul) -> Self::Output {
        Quantity::new(self, UnitDecilumens)
    }
}
pub struct UnitCentilumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentilumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentilumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentilumens {
    #[inline]
    fn clone(&self) -> UnitCentilumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentilumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentilumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentilumens {
    #[inline]
    fn eq(&self, other: &UnitCentilumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentilumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentilumens {
    fn default() -> Self {
        UnitCentilumens
    }
}
impl Add<UnitCentilumens> for UnitCentilumens {
    type Output = UnitCentilumens;
    #[inline]
    fn add(self, _: UnitCentilumens) -> Self::Output {
        UnitCentilumens
    }
}
impl AddAssign<UnitCentilumens> for UnitCentilumens {
    #[inline]
    fn add_assign(&mut self, _: UnitCentilumens) {}
}
impl Sub<UnitCentilumens> for UnitCentilumens {
    type Output = UnitCentilumens;
    #[inline]
    fn sub(self, _: UnitCentilumens) -> Self::Output {
        UnitCentilumens
    }
}
impl SubAssign<UnitCentilumens> for UnitCentilumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentilumens) {}
}
pub struct UnitCentilumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentilumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentilumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentilumensMul {
    #[inline]
    fn clone(&self) -> UnitCentilumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentilumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentilumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentilumensMul {
    #[inline]
    fn eq(&self, other: &UnitCentilumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentilumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentilumensMul> for i8 {
    type Output = Quantity<i8, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for i16 {
    type Output = Quantity<i16, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for i32 {
    type Output = Quantity<i32, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for i64 {
    type Output = Quantity<i64, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for i128 {
    type Output = Quantity<i128, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for isize {
    type Output = Quantity<isize, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for u8 {
    type Output = Quantity<u8, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for u16 {
    type Output = Quantity<u16, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for u32 {
    type Output = Quantity<u32, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for u64 {
    type Output = Quantity<u64, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for u128 {
    type Output = Quantity<u128, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for usize {
    type Output = Quantity<usize, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for f32 {
    type Output = Quantity<f32, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
impl Mul<UnitCentilumensMul> for f64 {
    type Output = Quantity<f64, UnitCentilumens>;
    fn mul(self, _: UnitCentilumensMul) -> Self::Output {
        Quantity::new(self, UnitCentilumens)
    }
}
pub struct UnitMillilumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillilumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillilumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillilumens {
    #[inline]
    fn clone(&self) -> UnitMillilumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillilumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillilumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillilumens {
    #[inline]
    fn eq(&self, other: &UnitMillilumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillilumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillilumens {
    fn default() -> Self {
        UnitMillilumens
    }
}
impl Add<UnitMillilumens> for UnitMillilumens {
    type Output = UnitMillilumens;
    #[inline]
    fn add(self, _: UnitMillilumens) -> Self::Output {
        UnitMillilumens
    }
}
impl AddAssign<UnitMillilumens> for UnitMillilumens {
    #[inline]
    fn add_assign(&mut self, _: UnitMillilumens) {}
}
impl Sub<UnitMillilumens> for UnitMillilumens {
    type Output = UnitMillilumens;
    #[inline]
    fn sub(self, _: UnitMillilumens) -> Self::Output {
        UnitMillilumens
    }
}
impl SubAssign<UnitMillilumens> for UnitMillilumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillilumens) {}
}
pub struct UnitMillilumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillilumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillilumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillilumensMul {
    #[inline]
    fn clone(&self) -> UnitMillilumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillilumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillilumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillilumensMul {
    #[inline]
    fn eq(&self, other: &UnitMillilumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillilumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillilumensMul> for i8 {
    type Output = Quantity<i8, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for i16 {
    type Output = Quantity<i16, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for i32 {
    type Output = Quantity<i32, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for i64 {
    type Output = Quantity<i64, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for i128 {
    type Output = Quantity<i128, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for isize {
    type Output = Quantity<isize, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for u8 {
    type Output = Quantity<u8, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for u16 {
    type Output = Quantity<u16, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for u32 {
    type Output = Quantity<u32, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for u64 {
    type Output = Quantity<u64, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for u128 {
    type Output = Quantity<u128, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for usize {
    type Output = Quantity<usize, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for f32 {
    type Output = Quantity<f32, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
impl Mul<UnitMillilumensMul> for f64 {
    type Output = Quantity<f64, UnitMillilumens>;
    fn mul(self, _: UnitMillilumensMul) -> Self::Output {
        Quantity::new(self, UnitMillilumens)
    }
}
pub struct UnitMicrolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrolumens {
    #[inline]
    fn clone(&self) -> UnitMicrolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrolumens {
    #[inline]
    fn eq(&self, other: &UnitMicrolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrolumens {
    fn default() -> Self {
        UnitMicrolumens
    }
}
impl Add<UnitMicrolumens> for UnitMicrolumens {
    type Output = UnitMicrolumens;
    #[inline]
    fn add(self, _: UnitMicrolumens) -> Self::Output {
        UnitMicrolumens
    }
}
impl AddAssign<UnitMicrolumens> for UnitMicrolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrolumens) {}
}
impl Sub<UnitMicrolumens> for UnitMicrolumens {
    type Output = UnitMicrolumens;
    #[inline]
    fn sub(self, _: UnitMicrolumens) -> Self::Output {
        UnitMicrolumens
    }
}
impl SubAssign<UnitMicrolumens> for UnitMicrolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrolumens) {}
}
pub struct UnitMicrolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrolumensMul {
    #[inline]
    fn clone(&self) -> UnitMicrolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrolumensMul {
    #[inline]
    fn eq(&self, other: &UnitMicrolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrolumensMul> for i8 {
    type Output = Quantity<i8, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for i16 {
    type Output = Quantity<i16, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for i32 {
    type Output = Quantity<i32, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for i64 {
    type Output = Quantity<i64, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for i128 {
    type Output = Quantity<i128, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for isize {
    type Output = Quantity<isize, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for u8 {
    type Output = Quantity<u8, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for u16 {
    type Output = Quantity<u16, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for u32 {
    type Output = Quantity<u32, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for u64 {
    type Output = Quantity<u64, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for u128 {
    type Output = Quantity<u128, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for usize {
    type Output = Quantity<usize, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for f32 {
    type Output = Quantity<f32, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
impl Mul<UnitMicrolumensMul> for f64 {
    type Output = Quantity<f64, UnitMicrolumens>;
    fn mul(self, _: UnitMicrolumensMul) -> Self::Output {
        Quantity::new(self, UnitMicrolumens)
    }
}
pub struct UnitNanolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanolumens {
    #[inline]
    fn clone(&self) -> UnitNanolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanolumens {
    #[inline]
    fn eq(&self, other: &UnitNanolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanolumens {
    fn default() -> Self {
        UnitNanolumens
    }
}
impl Add<UnitNanolumens> for UnitNanolumens {
    type Output = UnitNanolumens;
    #[inline]
    fn add(self, _: UnitNanolumens) -> Self::Output {
        UnitNanolumens
    }
}
impl AddAssign<UnitNanolumens> for UnitNanolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitNanolumens) {}
}
impl Sub<UnitNanolumens> for UnitNanolumens {
    type Output = UnitNanolumens;
    #[inline]
    fn sub(self, _: UnitNanolumens) -> Self::Output {
        UnitNanolumens
    }
}
impl SubAssign<UnitNanolumens> for UnitNanolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanolumens) {}
}
pub struct UnitNanolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanolumensMul {
    #[inline]
    fn clone(&self) -> UnitNanolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanolumensMul {
    #[inline]
    fn eq(&self, other: &UnitNanolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanolumensMul> for i8 {
    type Output = Quantity<i8, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for i16 {
    type Output = Quantity<i16, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for i32 {
    type Output = Quantity<i32, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for i64 {
    type Output = Quantity<i64, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for i128 {
    type Output = Quantity<i128, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for isize {
    type Output = Quantity<isize, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for u8 {
    type Output = Quantity<u8, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for u16 {
    type Output = Quantity<u16, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for u32 {
    type Output = Quantity<u32, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for u64 {
    type Output = Quantity<u64, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for u128 {
    type Output = Quantity<u128, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for usize {
    type Output = Quantity<usize, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for f32 {
    type Output = Quantity<f32, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
impl Mul<UnitNanolumensMul> for f64 {
    type Output = Quantity<f64, UnitNanolumens>;
    fn mul(self, _: UnitNanolumensMul) -> Self::Output {
        Quantity::new(self, UnitNanolumens)
    }
}
pub struct UnitPicolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicolumens {
    #[inline]
    fn clone(&self) -> UnitPicolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicolumens {
    #[inline]
    fn eq(&self, other: &UnitPicolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicolumens {
    fn default() -> Self {
        UnitPicolumens
    }
}
impl Add<UnitPicolumens> for UnitPicolumens {
    type Output = UnitPicolumens;
    #[inline]
    fn add(self, _: UnitPicolumens) -> Self::Output {
        UnitPicolumens
    }
}
impl AddAssign<UnitPicolumens> for UnitPicolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitPicolumens) {}
}
impl Sub<UnitPicolumens> for UnitPicolumens {
    type Output = UnitPicolumens;
    #[inline]
    fn sub(self, _: UnitPicolumens) -> Self::Output {
        UnitPicolumens
    }
}
impl SubAssign<UnitPicolumens> for UnitPicolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicolumens) {}
}
pub struct UnitPicolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicolumensMul {
    #[inline]
    fn clone(&self) -> UnitPicolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicolumensMul {
    #[inline]
    fn eq(&self, other: &UnitPicolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicolumensMul> for i8 {
    type Output = Quantity<i8, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for i16 {
    type Output = Quantity<i16, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for i32 {
    type Output = Quantity<i32, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for i64 {
    type Output = Quantity<i64, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for i128 {
    type Output = Quantity<i128, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for isize {
    type Output = Quantity<isize, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for u8 {
    type Output = Quantity<u8, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for u16 {
    type Output = Quantity<u16, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for u32 {
    type Output = Quantity<u32, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for u64 {
    type Output = Quantity<u64, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for u128 {
    type Output = Quantity<u128, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for usize {
    type Output = Quantity<usize, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for f32 {
    type Output = Quantity<f32, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
impl Mul<UnitPicolumensMul> for f64 {
    type Output = Quantity<f64, UnitPicolumens>;
    fn mul(self, _: UnitPicolumensMul) -> Self::Output {
        Quantity::new(self, UnitPicolumens)
    }
}
pub struct UnitFemtolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtolumens {
    #[inline]
    fn clone(&self) -> UnitFemtolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtolumens {
    #[inline]
    fn eq(&self, other: &UnitFemtolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtolumens {
    fn default() -> Self {
        UnitFemtolumens
    }
}
impl Add<UnitFemtolumens> for UnitFemtolumens {
    type Output = UnitFemtolumens;
    #[inline]
    fn add(self, _: UnitFemtolumens) -> Self::Output {
        UnitFemtolumens
    }
}
impl AddAssign<UnitFemtolumens> for UnitFemtolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtolumens) {}
}
impl Sub<UnitFemtolumens> for UnitFemtolumens {
    type Output = UnitFemtolumens;
    #[inline]
    fn sub(self, _: UnitFemtolumens) -> Self::Output {
        UnitFemtolumens
    }
}
impl SubAssign<UnitFemtolumens> for UnitFemtolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtolumens) {}
}
pub struct UnitFemtolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtolumensMul {
    #[inline]
    fn clone(&self) -> UnitFemtolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtolumensMul {
    #[inline]
    fn eq(&self, other: &UnitFemtolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtolumensMul> for i8 {
    type Output = Quantity<i8, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for i16 {
    type Output = Quantity<i16, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for i32 {
    type Output = Quantity<i32, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for i64 {
    type Output = Quantity<i64, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for i128 {
    type Output = Quantity<i128, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for isize {
    type Output = Quantity<isize, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for u8 {
    type Output = Quantity<u8, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for u16 {
    type Output = Quantity<u16, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for u32 {
    type Output = Quantity<u32, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for u64 {
    type Output = Quantity<u64, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for u128 {
    type Output = Quantity<u128, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for usize {
    type Output = Quantity<usize, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for f32 {
    type Output = Quantity<f32, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
impl Mul<UnitFemtolumensMul> for f64 {
    type Output = Quantity<f64, UnitFemtolumens>;
    fn mul(self, _: UnitFemtolumensMul) -> Self::Output {
        Quantity::new(self, UnitFemtolumens)
    }
}
pub struct UnitAttolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttolumens {
    #[inline]
    fn clone(&self) -> UnitAttolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttolumens {
    #[inline]
    fn eq(&self, other: &UnitAttolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttolumens {
    fn default() -> Self {
        UnitAttolumens
    }
}
impl Add<UnitAttolumens> for UnitAttolumens {
    type Output = UnitAttolumens;
    #[inline]
    fn add(self, _: UnitAttolumens) -> Self::Output {
        UnitAttolumens
    }
}
impl AddAssign<UnitAttolumens> for UnitAttolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitAttolumens) {}
}
impl Sub<UnitAttolumens> for UnitAttolumens {
    type Output = UnitAttolumens;
    #[inline]
    fn sub(self, _: UnitAttolumens) -> Self::Output {
        UnitAttolumens
    }
}
impl SubAssign<UnitAttolumens> for UnitAttolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttolumens) {}
}
pub struct UnitAttolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttolumensMul {
    #[inline]
    fn clone(&self) -> UnitAttolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttolumensMul {
    #[inline]
    fn eq(&self, other: &UnitAttolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttolumensMul> for i8 {
    type Output = Quantity<i8, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for i16 {
    type Output = Quantity<i16, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for i32 {
    type Output = Quantity<i32, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for i64 {
    type Output = Quantity<i64, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for i128 {
    type Output = Quantity<i128, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for isize {
    type Output = Quantity<isize, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for u8 {
    type Output = Quantity<u8, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for u16 {
    type Output = Quantity<u16, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for u32 {
    type Output = Quantity<u32, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for u64 {
    type Output = Quantity<u64, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for u128 {
    type Output = Quantity<u128, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for usize {
    type Output = Quantity<usize, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for f32 {
    type Output = Quantity<f32, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
impl Mul<UnitAttolumensMul> for f64 {
    type Output = Quantity<f64, UnitAttolumens>;
    fn mul(self, _: UnitAttolumensMul) -> Self::Output {
        Quantity::new(self, UnitAttolumens)
    }
}
pub struct UnitZeptolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptolumens {
    #[inline]
    fn clone(&self) -> UnitZeptolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptolumens {
    #[inline]
    fn eq(&self, other: &UnitZeptolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptolumens {
    fn default() -> Self {
        UnitZeptolumens
    }
}
impl Add<UnitZeptolumens> for UnitZeptolumens {
    type Output = UnitZeptolumens;
    #[inline]
    fn add(self, _: UnitZeptolumens) -> Self::Output {
        UnitZeptolumens
    }
}
impl AddAssign<UnitZeptolumens> for UnitZeptolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptolumens) {}
}
impl Sub<UnitZeptolumens> for UnitZeptolumens {
    type Output = UnitZeptolumens;
    #[inline]
    fn sub(self, _: UnitZeptolumens) -> Self::Output {
        UnitZeptolumens
    }
}
impl SubAssign<UnitZeptolumens> for UnitZeptolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptolumens) {}
}
pub struct UnitZeptolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptolumensMul {
    #[inline]
    fn clone(&self) -> UnitZeptolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptolumensMul {
    #[inline]
    fn eq(&self, other: &UnitZeptolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptolumensMul> for i8 {
    type Output = Quantity<i8, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for i16 {
    type Output = Quantity<i16, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for i32 {
    type Output = Quantity<i32, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for i64 {
    type Output = Quantity<i64, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for i128 {
    type Output = Quantity<i128, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for isize {
    type Output = Quantity<isize, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for u8 {
    type Output = Quantity<u8, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for u16 {
    type Output = Quantity<u16, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for u32 {
    type Output = Quantity<u32, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for u64 {
    type Output = Quantity<u64, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for u128 {
    type Output = Quantity<u128, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for usize {
    type Output = Quantity<usize, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for f32 {
    type Output = Quantity<f32, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
impl Mul<UnitZeptolumensMul> for f64 {
    type Output = Quantity<f64, UnitZeptolumens>;
    fn mul(self, _: UnitZeptolumensMul) -> Self::Output {
        Quantity::new(self, UnitZeptolumens)
    }
}
pub struct UnitYoctolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctolumens {
    #[inline]
    fn clone(&self) -> UnitYoctolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctolumens {
    #[inline]
    fn eq(&self, other: &UnitYoctolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctolumens {
    fn default() -> Self {
        UnitYoctolumens
    }
}
impl Add<UnitYoctolumens> for UnitYoctolumens {
    type Output = UnitYoctolumens;
    #[inline]
    fn add(self, _: UnitYoctolumens) -> Self::Output {
        UnitYoctolumens
    }
}
impl AddAssign<UnitYoctolumens> for UnitYoctolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctolumens) {}
}
impl Sub<UnitYoctolumens> for UnitYoctolumens {
    type Output = UnitYoctolumens;
    #[inline]
    fn sub(self, _: UnitYoctolumens) -> Self::Output {
        UnitYoctolumens
    }
}
impl SubAssign<UnitYoctolumens> for UnitYoctolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctolumens) {}
}
pub struct UnitYoctolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctolumensMul {
    #[inline]
    fn clone(&self) -> UnitYoctolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctolumensMul {
    #[inline]
    fn eq(&self, other: &UnitYoctolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctolumensMul> for i8 {
    type Output = Quantity<i8, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for i16 {
    type Output = Quantity<i16, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for i32 {
    type Output = Quantity<i32, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for i64 {
    type Output = Quantity<i64, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for i128 {
    type Output = Quantity<i128, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for isize {
    type Output = Quantity<isize, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for u8 {
    type Output = Quantity<u8, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for u16 {
    type Output = Quantity<u16, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for u32 {
    type Output = Quantity<u32, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for u64 {
    type Output = Quantity<u64, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for u128 {
    type Output = Quantity<u128, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for usize {
    type Output = Quantity<usize, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for f32 {
    type Output = Quantity<f32, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
impl Mul<UnitYoctolumensMul> for f64 {
    type Output = Quantity<f64, UnitYoctolumens>;
    fn mul(self, _: UnitYoctolumensMul) -> Self::Output {
        Quantity::new(self, UnitYoctolumens)
    }
}
pub struct UnitRontolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontolumens {
    #[inline]
    fn clone(&self) -> UnitRontolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontolumens {
    #[inline]
    fn eq(&self, other: &UnitRontolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontolumens {
    fn default() -> Self {
        UnitRontolumens
    }
}
impl Add<UnitRontolumens> for UnitRontolumens {
    type Output = UnitRontolumens;
    #[inline]
    fn add(self, _: UnitRontolumens) -> Self::Output {
        UnitRontolumens
    }
}
impl AddAssign<UnitRontolumens> for UnitRontolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitRontolumens) {}
}
impl Sub<UnitRontolumens> for UnitRontolumens {
    type Output = UnitRontolumens;
    #[inline]
    fn sub(self, _: UnitRontolumens) -> Self::Output {
        UnitRontolumens
    }
}
impl SubAssign<UnitRontolumens> for UnitRontolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontolumens) {}
}
pub struct UnitRontolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontolumensMul {
    #[inline]
    fn clone(&self) -> UnitRontolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontolumensMul {
    #[inline]
    fn eq(&self, other: &UnitRontolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontolumensMul> for i8 {
    type Output = Quantity<i8, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for i16 {
    type Output = Quantity<i16, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for i32 {
    type Output = Quantity<i32, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for i64 {
    type Output = Quantity<i64, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for i128 {
    type Output = Quantity<i128, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for isize {
    type Output = Quantity<isize, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for u8 {
    type Output = Quantity<u8, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for u16 {
    type Output = Quantity<u16, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for u32 {
    type Output = Quantity<u32, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for u64 {
    type Output = Quantity<u64, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for u128 {
    type Output = Quantity<u128, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for usize {
    type Output = Quantity<usize, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for f32 {
    type Output = Quantity<f32, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
impl Mul<UnitRontolumensMul> for f64 {
    type Output = Quantity<f64, UnitRontolumens>;
    fn mul(self, _: UnitRontolumensMul) -> Self::Output {
        Quantity::new(self, UnitRontolumens)
    }
}
pub struct UnitQuectolumens;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectolumens {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectolumens")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectolumens {
    #[inline]
    fn clone(&self) -> UnitQuectolumens {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectolumens {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectolumens {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectolumens {
    #[inline]
    fn eq(&self, other: &UnitQuectolumens) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectolumens {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectolumens {
    fn default() -> Self {
        UnitQuectolumens
    }
}
impl Add<UnitQuectolumens> for UnitQuectolumens {
    type Output = UnitQuectolumens;
    #[inline]
    fn add(self, _: UnitQuectolumens) -> Self::Output {
        UnitQuectolumens
    }
}
impl AddAssign<UnitQuectolumens> for UnitQuectolumens {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectolumens) {}
}
impl Sub<UnitQuectolumens> for UnitQuectolumens {
    type Output = UnitQuectolumens;
    #[inline]
    fn sub(self, _: UnitQuectolumens) -> Self::Output {
        UnitQuectolumens
    }
}
impl SubAssign<UnitQuectolumens> for UnitQuectolumens {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectolumens) {}
}
pub struct UnitQuectolumensMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectolumensMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectolumensMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectolumensMul {
    #[inline]
    fn clone(&self) -> UnitQuectolumensMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectolumensMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectolumensMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectolumensMul {
    #[inline]
    fn eq(&self, other: &UnitQuectolumensMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectolumensMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectolumensMul> for i8 {
    type Output = Quantity<i8, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for i16 {
    type Output = Quantity<i16, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for i32 {
    type Output = Quantity<i32, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for i64 {
    type Output = Quantity<i64, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for i128 {
    type Output = Quantity<i128, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for isize {
    type Output = Quantity<isize, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for u8 {
    type Output = Quantity<u8, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for u16 {
    type Output = Quantity<u16, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for u32 {
    type Output = Quantity<u32, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for u64 {
    type Output = Quantity<u64, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for u128 {
    type Output = Quantity<u128, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for usize {
    type Output = Quantity<usize, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for f32 {
    type Output = Quantity<f32, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
impl Mul<UnitQuectolumensMul> for f64 {
    type Output = Quantity<f64, UnitQuectolumens>;
    fn mul(self, _: UnitQuectolumensMul) -> Self::Output {
        Quantity::new(self, UnitQuectolumens)
    }
}
pub type Lumens<T> = Quantity<T, UnitLumens>;
#[allow(non_upper_case_globals)]
pub static Lumens: UnitLumensMul = UnitLumensMul;
pub type Quettalumens<T> = Quantity<T, UnitQuettalumens>;
#[allow(non_upper_case_globals)]
pub static Quettalumens: UnitQuettalumensMul = UnitQuettalumensMul;
pub type Ronnalumens<T> = Quantity<T, UnitRonnalumens>;
#[allow(non_upper_case_globals)]
pub static Ronnalumens: UnitRonnalumensMul = UnitRonnalumensMul;
pub type Yottalumens<T> = Quantity<T, UnitYottalumens>;
#[allow(non_upper_case_globals)]
pub static Yottalumens: UnitYottalumensMul = UnitYottalumensMul;
pub type Zettalumens<T> = Quantity<T, UnitZettalumens>;
#[allow(non_upper_case_globals)]
pub static Zettalumens: UnitZettalumensMul = UnitZettalumensMul;
pub type Exalumens<T> = Quantity<T, UnitExalumens>;
#[allow(non_upper_case_globals)]
pub static Exalumens: UnitExalumensMul = UnitExalumensMul;
pub type Petalumens<T> = Quantity<T, UnitPetalumens>;
#[allow(non_upper_case_globals)]
pub static Petalumens: UnitPetalumensMul = UnitPetalumensMul;
pub type Teralumens<T> = Quantity<T, UnitTeralumens>;
#[allow(non_upper_case_globals)]
pub static Teralumens: UnitTeralumensMul = UnitTeralumensMul;
pub type Gigalumens<T> = Quantity<T, UnitGigalumens>;
#[allow(non_upper_case_globals)]
pub static Gigalumens: UnitGigalumensMul = UnitGigalumensMul;
pub type Megalumens<T> = Quantity<T, UnitMegalumens>;
#[allow(non_upper_case_globals)]
pub static Megalumens: UnitMegalumensMul = UnitMegalumensMul;
pub type Kilolumens<T> = Quantity<T, UnitKilolumens>;
#[allow(non_upper_case_globals)]
pub static Kilolumens: UnitKilolumensMul = UnitKilolumensMul;
pub type Hectolumens<T> = Quantity<T, UnitHectolumens>;
#[allow(non_upper_case_globals)]
pub static Hectolumens: UnitHectolumensMul = UnitHectolumensMul;
pub type Decalumens<T> = Quantity<T, UnitDecalumens>;
#[allow(non_upper_case_globals)]
pub static Decalumens: UnitDecalumensMul = UnitDecalumensMul;
pub type Decilumens<T> = Quantity<T, UnitDecilumens>;
#[allow(non_upper_case_globals)]
pub static Decilumens: UnitDecilumensMul = UnitDecilumensMul;
pub type Centilumens<T> = Quantity<T, UnitCentilumens>;
#[allow(non_upper_case_globals)]
pub static Centilumens: UnitCentilumensMul = UnitCentilumensMul;
pub type Millilumens<T> = Quantity<T, UnitMillilumens>;
#[allow(non_upper_case_globals)]
pub static Millilumens: UnitMillilumensMul = UnitMillilumensMul;
pub type Microlumens<T> = Quantity<T, UnitMicrolumens>;
#[allow(non_upper_case_globals)]
pub static Microlumens: UnitMicrolumensMul = UnitMicrolumensMul;
pub type Nanolumens<T> = Quantity<T, UnitNanolumens>;
#[allow(non_upper_case_globals)]
pub static Nanolumens: UnitNanolumensMul = UnitNanolumensMul;
pub type Picolumens<T> = Quantity<T, UnitPicolumens>;
#[allow(non_upper_case_globals)]
pub static Picolumens: UnitPicolumensMul = UnitPicolumensMul;
pub type Femtolumens<T> = Quantity<T, UnitFemtolumens>;
#[allow(non_upper_case_globals)]
pub static Femtolumens: UnitFemtolumensMul = UnitFemtolumensMul;
pub type Attolumens<T> = Quantity<T, UnitAttolumens>;
#[allow(non_upper_case_globals)]
pub static Attolumens: UnitAttolumensMul = UnitAttolumensMul;
pub type Zeptolumens<T> = Quantity<T, UnitZeptolumens>;
#[allow(non_upper_case_globals)]
pub static Zeptolumens: UnitZeptolumensMul = UnitZeptolumensMul;
pub type Yoctolumens<T> = Quantity<T, UnitYoctolumens>;
#[allow(non_upper_case_globals)]
pub static Yoctolumens: UnitYoctolumensMul = UnitYoctolumensMul;
pub type Rontolumens<T> = Quantity<T, UnitRontolumens>;
#[allow(non_upper_case_globals)]
pub static Rontolumens: UnitRontolumensMul = UnitRontolumensMul;
pub type Quectolumens<T> = Quantity<T, UnitQuectolumens>;
#[allow(non_upper_case_globals)]
pub static Quectolumens: UnitQuectolumensMul = UnitQuectolumensMul;
pub struct UnitLux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitLux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitLux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitLux {
    #[inline]
    fn clone(&self) -> UnitLux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitLux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitLux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitLux {
    #[inline]
    fn eq(&self, other: &UnitLux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitLux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitLux {
    fn default() -> Self {
        UnitLux
    }
}
impl Add<UnitLux> for UnitLux {
    type Output = UnitLux;
    #[inline]
    fn add(self, _: UnitLux) -> Self::Output {
        UnitLux
    }
}
impl AddAssign<UnitLux> for UnitLux {
    #[inline]
    fn add_assign(&mut self, _: UnitLux) {}
}
impl Sub<UnitLux> for UnitLux {
    type Output = UnitLux;
    #[inline]
    fn sub(self, _: UnitLux) -> Self::Output {
        UnitLux
    }
}
impl SubAssign<UnitLux> for UnitLux {
    #[inline]
    fn sub_assign(&mut self, _: UnitLux) {}
}
pub struct UnitLuxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitLuxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitLuxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitLuxMul {
    #[inline]
    fn clone(&self) -> UnitLuxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitLuxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitLuxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitLuxMul {
    #[inline]
    fn eq(&self, other: &UnitLuxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitLuxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitLuxMul> for i8 {
    type Output = Quantity<i8, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for i16 {
    type Output = Quantity<i16, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for i32 {
    type Output = Quantity<i32, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for i64 {
    type Output = Quantity<i64, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for i128 {
    type Output = Quantity<i128, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for isize {
    type Output = Quantity<isize, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for u8 {
    type Output = Quantity<u8, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for u16 {
    type Output = Quantity<u16, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for u32 {
    type Output = Quantity<u32, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for u64 {
    type Output = Quantity<u64, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for u128 {
    type Output = Quantity<u128, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for usize {
    type Output = Quantity<usize, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for f32 {
    type Output = Quantity<f32, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
impl Mul<UnitLuxMul> for f64 {
    type Output = Quantity<f64, UnitLux>;
    fn mul(self, _: UnitLuxMul) -> Self::Output {
        Quantity::new(self, UnitLux)
    }
}
pub struct UnitQuettalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettalux {
    #[inline]
    fn clone(&self) -> UnitQuettalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettalux {
    #[inline]
    fn eq(&self, other: &UnitQuettalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettalux {
    fn default() -> Self {
        UnitQuettalux
    }
}
impl Add<UnitQuettalux> for UnitQuettalux {
    type Output = UnitQuettalux;
    #[inline]
    fn add(self, _: UnitQuettalux) -> Self::Output {
        UnitQuettalux
    }
}
impl AddAssign<UnitQuettalux> for UnitQuettalux {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettalux) {}
}
impl Sub<UnitQuettalux> for UnitQuettalux {
    type Output = UnitQuettalux;
    #[inline]
    fn sub(self, _: UnitQuettalux) -> Self::Output {
        UnitQuettalux
    }
}
impl SubAssign<UnitQuettalux> for UnitQuettalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettalux) {}
}
pub struct UnitQuettaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaluxMul {
    #[inline]
    fn clone(&self) -> UnitQuettaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaluxMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaluxMul> for i8 {
    type Output = Quantity<i8, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for i16 {
    type Output = Quantity<i16, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for i32 {
    type Output = Quantity<i32, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for i64 {
    type Output = Quantity<i64, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for i128 {
    type Output = Quantity<i128, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for isize {
    type Output = Quantity<isize, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for u8 {
    type Output = Quantity<u8, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for u16 {
    type Output = Quantity<u16, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for u32 {
    type Output = Quantity<u32, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for u64 {
    type Output = Quantity<u64, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for u128 {
    type Output = Quantity<u128, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for usize {
    type Output = Quantity<usize, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for f32 {
    type Output = Quantity<f32, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
impl Mul<UnitQuettaluxMul> for f64 {
    type Output = Quantity<f64, UnitQuettalux>;
    fn mul(self, _: UnitQuettaluxMul) -> Self::Output {
        Quantity::new(self, UnitQuettalux)
    }
}
pub struct UnitRonnalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnalux {
    #[inline]
    fn clone(&self) -> UnitRonnalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnalux {
    #[inline]
    fn eq(&self, other: &UnitRonnalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnalux {
    fn default() -> Self {
        UnitRonnalux
    }
}
impl Add<UnitRonnalux> for UnitRonnalux {
    type Output = UnitRonnalux;
    #[inline]
    fn add(self, _: UnitRonnalux) -> Self::Output {
        UnitRonnalux
    }
}
impl AddAssign<UnitRonnalux> for UnitRonnalux {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnalux) {}
}
impl Sub<UnitRonnalux> for UnitRonnalux {
    type Output = UnitRonnalux;
    #[inline]
    fn sub(self, _: UnitRonnalux) -> Self::Output {
        UnitRonnalux
    }
}
impl SubAssign<UnitRonnalux> for UnitRonnalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnalux) {}
}
pub struct UnitRonnaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaluxMul {
    #[inline]
    fn clone(&self) -> UnitRonnaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaluxMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaluxMul> for i8 {
    type Output = Quantity<i8, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for i16 {
    type Output = Quantity<i16, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for i32 {
    type Output = Quantity<i32, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for i64 {
    type Output = Quantity<i64, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for i128 {
    type Output = Quantity<i128, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for isize {
    type Output = Quantity<isize, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for u8 {
    type Output = Quantity<u8, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for u16 {
    type Output = Quantity<u16, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for u32 {
    type Output = Quantity<u32, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for u64 {
    type Output = Quantity<u64, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for u128 {
    type Output = Quantity<u128, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for usize {
    type Output = Quantity<usize, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for f32 {
    type Output = Quantity<f32, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
impl Mul<UnitRonnaluxMul> for f64 {
    type Output = Quantity<f64, UnitRonnalux>;
    fn mul(self, _: UnitRonnaluxMul) -> Self::Output {
        Quantity::new(self, UnitRonnalux)
    }
}
pub struct UnitYottalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottalux {
    #[inline]
    fn clone(&self) -> UnitYottalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottalux {
    #[inline]
    fn eq(&self, other: &UnitYottalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottalux {
    fn default() -> Self {
        UnitYottalux
    }
}
impl Add<UnitYottalux> for UnitYottalux {
    type Output = UnitYottalux;
    #[inline]
    fn add(self, _: UnitYottalux) -> Self::Output {
        UnitYottalux
    }
}
impl AddAssign<UnitYottalux> for UnitYottalux {
    #[inline]
    fn add_assign(&mut self, _: UnitYottalux) {}
}
impl Sub<UnitYottalux> for UnitYottalux {
    type Output = UnitYottalux;
    #[inline]
    fn sub(self, _: UnitYottalux) -> Self::Output {
        UnitYottalux
    }
}
impl SubAssign<UnitYottalux> for UnitYottalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottalux) {}
}
pub struct UnitYottaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaluxMul {
    #[inline]
    fn clone(&self) -> UnitYottaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaluxMul {
    #[inline]
    fn eq(&self, other: &UnitYottaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaluxMul> for i8 {
    type Output = Quantity<i8, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for i16 {
    type Output = Quantity<i16, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for i32 {
    type Output = Quantity<i32, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for i64 {
    type Output = Quantity<i64, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for i128 {
    type Output = Quantity<i128, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for isize {
    type Output = Quantity<isize, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for u8 {
    type Output = Quantity<u8, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for u16 {
    type Output = Quantity<u16, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for u32 {
    type Output = Quantity<u32, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for u64 {
    type Output = Quantity<u64, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for u128 {
    type Output = Quantity<u128, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for usize {
    type Output = Quantity<usize, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for f32 {
    type Output = Quantity<f32, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
impl Mul<UnitYottaluxMul> for f64 {
    type Output = Quantity<f64, UnitYottalux>;
    fn mul(self, _: UnitYottaluxMul) -> Self::Output {
        Quantity::new(self, UnitYottalux)
    }
}
pub struct UnitZettalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettalux {
    #[inline]
    fn clone(&self) -> UnitZettalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettalux {
    #[inline]
    fn eq(&self, other: &UnitZettalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettalux {
    fn default() -> Self {
        UnitZettalux
    }
}
impl Add<UnitZettalux> for UnitZettalux {
    type Output = UnitZettalux;
    #[inline]
    fn add(self, _: UnitZettalux) -> Self::Output {
        UnitZettalux
    }
}
impl AddAssign<UnitZettalux> for UnitZettalux {
    #[inline]
    fn add_assign(&mut self, _: UnitZettalux) {}
}
impl Sub<UnitZettalux> for UnitZettalux {
    type Output = UnitZettalux;
    #[inline]
    fn sub(self, _: UnitZettalux) -> Self::Output {
        UnitZettalux
    }
}
impl SubAssign<UnitZettalux> for UnitZettalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettalux) {}
}
pub struct UnitZettaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaluxMul {
    #[inline]
    fn clone(&self) -> UnitZettaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaluxMul {
    #[inline]
    fn eq(&self, other: &UnitZettaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaluxMul> for i8 {
    type Output = Quantity<i8, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for i16 {
    type Output = Quantity<i16, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for i32 {
    type Output = Quantity<i32, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for i64 {
    type Output = Quantity<i64, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for i128 {
    type Output = Quantity<i128, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for isize {
    type Output = Quantity<isize, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for u8 {
    type Output = Quantity<u8, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for u16 {
    type Output = Quantity<u16, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for u32 {
    type Output = Quantity<u32, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for u64 {
    type Output = Quantity<u64, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for u128 {
    type Output = Quantity<u128, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for usize {
    type Output = Quantity<usize, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for f32 {
    type Output = Quantity<f32, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
impl Mul<UnitZettaluxMul> for f64 {
    type Output = Quantity<f64, UnitZettalux>;
    fn mul(self, _: UnitZettaluxMul) -> Self::Output {
        Quantity::new(self, UnitZettalux)
    }
}
pub struct UnitExalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExalux {
    #[inline]
    fn clone(&self) -> UnitExalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExalux {
    #[inline]
    fn eq(&self, other: &UnitExalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExalux {
    fn default() -> Self {
        UnitExalux
    }
}
impl Add<UnitExalux> for UnitExalux {
    type Output = UnitExalux;
    #[inline]
    fn add(self, _: UnitExalux) -> Self::Output {
        UnitExalux
    }
}
impl AddAssign<UnitExalux> for UnitExalux {
    #[inline]
    fn add_assign(&mut self, _: UnitExalux) {}
}
impl Sub<UnitExalux> for UnitExalux {
    type Output = UnitExalux;
    #[inline]
    fn sub(self, _: UnitExalux) -> Self::Output {
        UnitExalux
    }
}
impl SubAssign<UnitExalux> for UnitExalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitExalux) {}
}
pub struct UnitExaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaluxMul {
    #[inline]
    fn clone(&self) -> UnitExaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaluxMul {
    #[inline]
    fn eq(&self, other: &UnitExaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaluxMul> for i8 {
    type Output = Quantity<i8, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for i16 {
    type Output = Quantity<i16, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for i32 {
    type Output = Quantity<i32, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for i64 {
    type Output = Quantity<i64, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for i128 {
    type Output = Quantity<i128, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for isize {
    type Output = Quantity<isize, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for u8 {
    type Output = Quantity<u8, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for u16 {
    type Output = Quantity<u16, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for u32 {
    type Output = Quantity<u32, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for u64 {
    type Output = Quantity<u64, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for u128 {
    type Output = Quantity<u128, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for usize {
    type Output = Quantity<usize, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for f32 {
    type Output = Quantity<f32, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
impl Mul<UnitExaluxMul> for f64 {
    type Output = Quantity<f64, UnitExalux>;
    fn mul(self, _: UnitExaluxMul) -> Self::Output {
        Quantity::new(self, UnitExalux)
    }
}
pub struct UnitPetalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetalux {
    #[inline]
    fn clone(&self) -> UnitPetalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetalux {
    #[inline]
    fn eq(&self, other: &UnitPetalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetalux {
    fn default() -> Self {
        UnitPetalux
    }
}
impl Add<UnitPetalux> for UnitPetalux {
    type Output = UnitPetalux;
    #[inline]
    fn add(self, _: UnitPetalux) -> Self::Output {
        UnitPetalux
    }
}
impl AddAssign<UnitPetalux> for UnitPetalux {
    #[inline]
    fn add_assign(&mut self, _: UnitPetalux) {}
}
impl Sub<UnitPetalux> for UnitPetalux {
    type Output = UnitPetalux;
    #[inline]
    fn sub(self, _: UnitPetalux) -> Self::Output {
        UnitPetalux
    }
}
impl SubAssign<UnitPetalux> for UnitPetalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetalux) {}
}
pub struct UnitPetaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaluxMul {
    #[inline]
    fn clone(&self) -> UnitPetaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaluxMul {
    #[inline]
    fn eq(&self, other: &UnitPetaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaluxMul> for i8 {
    type Output = Quantity<i8, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for i16 {
    type Output = Quantity<i16, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for i32 {
    type Output = Quantity<i32, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for i64 {
    type Output = Quantity<i64, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for i128 {
    type Output = Quantity<i128, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for isize {
    type Output = Quantity<isize, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for u8 {
    type Output = Quantity<u8, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for u16 {
    type Output = Quantity<u16, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for u32 {
    type Output = Quantity<u32, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for u64 {
    type Output = Quantity<u64, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for u128 {
    type Output = Quantity<u128, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for usize {
    type Output = Quantity<usize, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for f32 {
    type Output = Quantity<f32, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
impl Mul<UnitPetaluxMul> for f64 {
    type Output = Quantity<f64, UnitPetalux>;
    fn mul(self, _: UnitPetaluxMul) -> Self::Output {
        Quantity::new(self, UnitPetalux)
    }
}
pub struct UnitTeralux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeralux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeralux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeralux {
    #[inline]
    fn clone(&self) -> UnitTeralux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeralux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeralux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeralux {
    #[inline]
    fn eq(&self, other: &UnitTeralux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeralux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeralux {
    fn default() -> Self {
        UnitTeralux
    }
}
impl Add<UnitTeralux> for UnitTeralux {
    type Output = UnitTeralux;
    #[inline]
    fn add(self, _: UnitTeralux) -> Self::Output {
        UnitTeralux
    }
}
impl AddAssign<UnitTeralux> for UnitTeralux {
    #[inline]
    fn add_assign(&mut self, _: UnitTeralux) {}
}
impl Sub<UnitTeralux> for UnitTeralux {
    type Output = UnitTeralux;
    #[inline]
    fn sub(self, _: UnitTeralux) -> Self::Output {
        UnitTeralux
    }
}
impl SubAssign<UnitTeralux> for UnitTeralux {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeralux) {}
}
pub struct UnitTeraluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraluxMul {
    #[inline]
    fn clone(&self) -> UnitTeraluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraluxMul {
    #[inline]
    fn eq(&self, other: &UnitTeraluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraluxMul> for i8 {
    type Output = Quantity<i8, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for i16 {
    type Output = Quantity<i16, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for i32 {
    type Output = Quantity<i32, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for i64 {
    type Output = Quantity<i64, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for i128 {
    type Output = Quantity<i128, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for isize {
    type Output = Quantity<isize, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for u8 {
    type Output = Quantity<u8, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for u16 {
    type Output = Quantity<u16, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for u32 {
    type Output = Quantity<u32, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for u64 {
    type Output = Quantity<u64, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for u128 {
    type Output = Quantity<u128, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for usize {
    type Output = Quantity<usize, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for f32 {
    type Output = Quantity<f32, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
impl Mul<UnitTeraluxMul> for f64 {
    type Output = Quantity<f64, UnitTeralux>;
    fn mul(self, _: UnitTeraluxMul) -> Self::Output {
        Quantity::new(self, UnitTeralux)
    }
}
pub struct UnitGigalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigalux {
    #[inline]
    fn clone(&self) -> UnitGigalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigalux {
    #[inline]
    fn eq(&self, other: &UnitGigalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigalux {
    fn default() -> Self {
        UnitGigalux
    }
}
impl Add<UnitGigalux> for UnitGigalux {
    type Output = UnitGigalux;
    #[inline]
    fn add(self, _: UnitGigalux) -> Self::Output {
        UnitGigalux
    }
}
impl AddAssign<UnitGigalux> for UnitGigalux {
    #[inline]
    fn add_assign(&mut self, _: UnitGigalux) {}
}
impl Sub<UnitGigalux> for UnitGigalux {
    type Output = UnitGigalux;
    #[inline]
    fn sub(self, _: UnitGigalux) -> Self::Output {
        UnitGigalux
    }
}
impl SubAssign<UnitGigalux> for UnitGigalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigalux) {}
}
pub struct UnitGigaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaluxMul {
    #[inline]
    fn clone(&self) -> UnitGigaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaluxMul {
    #[inline]
    fn eq(&self, other: &UnitGigaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaluxMul> for i8 {
    type Output = Quantity<i8, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for i16 {
    type Output = Quantity<i16, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for i32 {
    type Output = Quantity<i32, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for i64 {
    type Output = Quantity<i64, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for i128 {
    type Output = Quantity<i128, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for isize {
    type Output = Quantity<isize, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for u8 {
    type Output = Quantity<u8, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for u16 {
    type Output = Quantity<u16, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for u32 {
    type Output = Quantity<u32, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for u64 {
    type Output = Quantity<u64, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for u128 {
    type Output = Quantity<u128, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for usize {
    type Output = Quantity<usize, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for f32 {
    type Output = Quantity<f32, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
impl Mul<UnitGigaluxMul> for f64 {
    type Output = Quantity<f64, UnitGigalux>;
    fn mul(self, _: UnitGigaluxMul) -> Self::Output {
        Quantity::new(self, UnitGigalux)
    }
}
pub struct UnitMegalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegalux {
    #[inline]
    fn clone(&self) -> UnitMegalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegalux {
    #[inline]
    fn eq(&self, other: &UnitMegalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegalux {
    fn default() -> Self {
        UnitMegalux
    }
}
impl Add<UnitMegalux> for UnitMegalux {
    type Output = UnitMegalux;
    #[inline]
    fn add(self, _: UnitMegalux) -> Self::Output {
        UnitMegalux
    }
}
impl AddAssign<UnitMegalux> for UnitMegalux {
    #[inline]
    fn add_assign(&mut self, _: UnitMegalux) {}
}
impl Sub<UnitMegalux> for UnitMegalux {
    type Output = UnitMegalux;
    #[inline]
    fn sub(self, _: UnitMegalux) -> Self::Output {
        UnitMegalux
    }
}
impl SubAssign<UnitMegalux> for UnitMegalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegalux) {}
}
pub struct UnitMegaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaluxMul {
    #[inline]
    fn clone(&self) -> UnitMegaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaluxMul {
    #[inline]
    fn eq(&self, other: &UnitMegaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaluxMul> for i8 {
    type Output = Quantity<i8, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for i16 {
    type Output = Quantity<i16, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for i32 {
    type Output = Quantity<i32, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for i64 {
    type Output = Quantity<i64, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for i128 {
    type Output = Quantity<i128, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for isize {
    type Output = Quantity<isize, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for u8 {
    type Output = Quantity<u8, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for u16 {
    type Output = Quantity<u16, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for u32 {
    type Output = Quantity<u32, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for u64 {
    type Output = Quantity<u64, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for u128 {
    type Output = Quantity<u128, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for usize {
    type Output = Quantity<usize, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for f32 {
    type Output = Quantity<f32, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
impl Mul<UnitMegaluxMul> for f64 {
    type Output = Quantity<f64, UnitMegalux>;
    fn mul(self, _: UnitMegaluxMul) -> Self::Output {
        Quantity::new(self, UnitMegalux)
    }
}
pub struct UnitKilolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilolux {
    #[inline]
    fn clone(&self) -> UnitKilolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilolux {
    #[inline]
    fn eq(&self, other: &UnitKilolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilolux {
    fn default() -> Self {
        UnitKilolux
    }
}
impl Add<UnitKilolux> for UnitKilolux {
    type Output = UnitKilolux;
    #[inline]
    fn add(self, _: UnitKilolux) -> Self::Output {
        UnitKilolux
    }
}
impl AddAssign<UnitKilolux> for UnitKilolux {
    #[inline]
    fn add_assign(&mut self, _: UnitKilolux) {}
}
impl Sub<UnitKilolux> for UnitKilolux {
    type Output = UnitKilolux;
    #[inline]
    fn sub(self, _: UnitKilolux) -> Self::Output {
        UnitKilolux
    }
}
impl SubAssign<UnitKilolux> for UnitKilolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilolux) {}
}
pub struct UnitKiloluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloluxMul {
    #[inline]
    fn clone(&self) -> UnitKiloluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloluxMul {
    #[inline]
    fn eq(&self, other: &UnitKiloluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloluxMul> for i8 {
    type Output = Quantity<i8, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for i16 {
    type Output = Quantity<i16, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for i32 {
    type Output = Quantity<i32, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for i64 {
    type Output = Quantity<i64, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for i128 {
    type Output = Quantity<i128, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for isize {
    type Output = Quantity<isize, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for u8 {
    type Output = Quantity<u8, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for u16 {
    type Output = Quantity<u16, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for u32 {
    type Output = Quantity<u32, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for u64 {
    type Output = Quantity<u64, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for u128 {
    type Output = Quantity<u128, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for usize {
    type Output = Quantity<usize, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for f32 {
    type Output = Quantity<f32, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
impl Mul<UnitKiloluxMul> for f64 {
    type Output = Quantity<f64, UnitKilolux>;
    fn mul(self, _: UnitKiloluxMul) -> Self::Output {
        Quantity::new(self, UnitKilolux)
    }
}
pub struct UnitHectolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectolux {
    #[inline]
    fn clone(&self) -> UnitHectolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectolux {
    #[inline]
    fn eq(&self, other: &UnitHectolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectolux {
    fn default() -> Self {
        UnitHectolux
    }
}
impl Add<UnitHectolux> for UnitHectolux {
    type Output = UnitHectolux;
    #[inline]
    fn add(self, _: UnitHectolux) -> Self::Output {
        UnitHectolux
    }
}
impl AddAssign<UnitHectolux> for UnitHectolux {
    #[inline]
    fn add_assign(&mut self, _: UnitHectolux) {}
}
impl Sub<UnitHectolux> for UnitHectolux {
    type Output = UnitHectolux;
    #[inline]
    fn sub(self, _: UnitHectolux) -> Self::Output {
        UnitHectolux
    }
}
impl SubAssign<UnitHectolux> for UnitHectolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectolux) {}
}
pub struct UnitHectoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoluxMul {
    #[inline]
    fn clone(&self) -> UnitHectoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoluxMul {
    #[inline]
    fn eq(&self, other: &UnitHectoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoluxMul> for i8 {
    type Output = Quantity<i8, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for i16 {
    type Output = Quantity<i16, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for i32 {
    type Output = Quantity<i32, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for i64 {
    type Output = Quantity<i64, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for i128 {
    type Output = Quantity<i128, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for isize {
    type Output = Quantity<isize, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for u8 {
    type Output = Quantity<u8, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for u16 {
    type Output = Quantity<u16, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for u32 {
    type Output = Quantity<u32, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for u64 {
    type Output = Quantity<u64, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for u128 {
    type Output = Quantity<u128, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for usize {
    type Output = Quantity<usize, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for f32 {
    type Output = Quantity<f32, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
impl Mul<UnitHectoluxMul> for f64 {
    type Output = Quantity<f64, UnitHectolux>;
    fn mul(self, _: UnitHectoluxMul) -> Self::Output {
        Quantity::new(self, UnitHectolux)
    }
}
pub struct UnitDecalux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecalux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecalux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecalux {
    #[inline]
    fn clone(&self) -> UnitDecalux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecalux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecalux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecalux {
    #[inline]
    fn eq(&self, other: &UnitDecalux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecalux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecalux {
    fn default() -> Self {
        UnitDecalux
    }
}
impl Add<UnitDecalux> for UnitDecalux {
    type Output = UnitDecalux;
    #[inline]
    fn add(self, _: UnitDecalux) -> Self::Output {
        UnitDecalux
    }
}
impl AddAssign<UnitDecalux> for UnitDecalux {
    #[inline]
    fn add_assign(&mut self, _: UnitDecalux) {}
}
impl Sub<UnitDecalux> for UnitDecalux {
    type Output = UnitDecalux;
    #[inline]
    fn sub(self, _: UnitDecalux) -> Self::Output {
        UnitDecalux
    }
}
impl SubAssign<UnitDecalux> for UnitDecalux {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecalux) {}
}
pub struct UnitDecaluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaluxMul {
    #[inline]
    fn clone(&self) -> UnitDecaluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaluxMul {
    #[inline]
    fn eq(&self, other: &UnitDecaluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaluxMul> for i8 {
    type Output = Quantity<i8, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for i16 {
    type Output = Quantity<i16, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for i32 {
    type Output = Quantity<i32, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for i64 {
    type Output = Quantity<i64, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for i128 {
    type Output = Quantity<i128, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for isize {
    type Output = Quantity<isize, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for u8 {
    type Output = Quantity<u8, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for u16 {
    type Output = Quantity<u16, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for u32 {
    type Output = Quantity<u32, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for u64 {
    type Output = Quantity<u64, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for u128 {
    type Output = Quantity<u128, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for usize {
    type Output = Quantity<usize, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for f32 {
    type Output = Quantity<f32, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
impl Mul<UnitDecaluxMul> for f64 {
    type Output = Quantity<f64, UnitDecalux>;
    fn mul(self, _: UnitDecaluxMul) -> Self::Output {
        Quantity::new(self, UnitDecalux)
    }
}
pub struct UnitDecilux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecilux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecilux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecilux {
    #[inline]
    fn clone(&self) -> UnitDecilux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecilux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecilux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecilux {
    #[inline]
    fn eq(&self, other: &UnitDecilux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecilux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecilux {
    fn default() -> Self {
        UnitDecilux
    }
}
impl Add<UnitDecilux> for UnitDecilux {
    type Output = UnitDecilux;
    #[inline]
    fn add(self, _: UnitDecilux) -> Self::Output {
        UnitDecilux
    }
}
impl AddAssign<UnitDecilux> for UnitDecilux {
    #[inline]
    fn add_assign(&mut self, _: UnitDecilux) {}
}
impl Sub<UnitDecilux> for UnitDecilux {
    type Output = UnitDecilux;
    #[inline]
    fn sub(self, _: UnitDecilux) -> Self::Output {
        UnitDecilux
    }
}
impl SubAssign<UnitDecilux> for UnitDecilux {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecilux) {}
}
pub struct UnitDeciluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciluxMul {
    #[inline]
    fn clone(&self) -> UnitDeciluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciluxMul {
    #[inline]
    fn eq(&self, other: &UnitDeciluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciluxMul> for i8 {
    type Output = Quantity<i8, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for i16 {
    type Output = Quantity<i16, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for i32 {
    type Output = Quantity<i32, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for i64 {
    type Output = Quantity<i64, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for i128 {
    type Output = Quantity<i128, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for isize {
    type Output = Quantity<isize, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for u8 {
    type Output = Quantity<u8, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for u16 {
    type Output = Quantity<u16, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for u32 {
    type Output = Quantity<u32, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for u64 {
    type Output = Quantity<u64, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for u128 {
    type Output = Quantity<u128, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for usize {
    type Output = Quantity<usize, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for f32 {
    type Output = Quantity<f32, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
impl Mul<UnitDeciluxMul> for f64 {
    type Output = Quantity<f64, UnitDecilux>;
    fn mul(self, _: UnitDeciluxMul) -> Self::Output {
        Quantity::new(self, UnitDecilux)
    }
}
pub struct UnitCentilux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentilux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentilux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentilux {
    #[inline]
    fn clone(&self) -> UnitCentilux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentilux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentilux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentilux {
    #[inline]
    fn eq(&self, other: &UnitCentilux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentilux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentilux {
    fn default() -> Self {
        UnitCentilux
    }
}
impl Add<UnitCentilux> for UnitCentilux {
    type Output = UnitCentilux;
    #[inline]
    fn add(self, _: UnitCentilux) -> Self::Output {
        UnitCentilux
    }
}
impl AddAssign<UnitCentilux> for UnitCentilux {
    #[inline]
    fn add_assign(&mut self, _: UnitCentilux) {}
}
impl Sub<UnitCentilux> for UnitCentilux {
    type Output = UnitCentilux;
    #[inline]
    fn sub(self, _: UnitCentilux) -> Self::Output {
        UnitCentilux
    }
}
impl SubAssign<UnitCentilux> for UnitCentilux {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentilux) {}
}
pub struct UnitCentiluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiluxMul {
    #[inline]
    fn clone(&self) -> UnitCentiluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiluxMul {
    #[inline]
    fn eq(&self, other: &UnitCentiluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiluxMul> for i8 {
    type Output = Quantity<i8, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for i16 {
    type Output = Quantity<i16, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for i32 {
    type Output = Quantity<i32, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for i64 {
    type Output = Quantity<i64, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for i128 {
    type Output = Quantity<i128, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for isize {
    type Output = Quantity<isize, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for u8 {
    type Output = Quantity<u8, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for u16 {
    type Output = Quantity<u16, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for u32 {
    type Output = Quantity<u32, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for u64 {
    type Output = Quantity<u64, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for u128 {
    type Output = Quantity<u128, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for usize {
    type Output = Quantity<usize, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for f32 {
    type Output = Quantity<f32, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
impl Mul<UnitCentiluxMul> for f64 {
    type Output = Quantity<f64, UnitCentilux>;
    fn mul(self, _: UnitCentiluxMul) -> Self::Output {
        Quantity::new(self, UnitCentilux)
    }
}
pub struct UnitMillilux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillilux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillilux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillilux {
    #[inline]
    fn clone(&self) -> UnitMillilux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillilux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillilux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillilux {
    #[inline]
    fn eq(&self, other: &UnitMillilux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillilux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillilux {
    fn default() -> Self {
        UnitMillilux
    }
}
impl Add<UnitMillilux> for UnitMillilux {
    type Output = UnitMillilux;
    #[inline]
    fn add(self, _: UnitMillilux) -> Self::Output {
        UnitMillilux
    }
}
impl AddAssign<UnitMillilux> for UnitMillilux {
    #[inline]
    fn add_assign(&mut self, _: UnitMillilux) {}
}
impl Sub<UnitMillilux> for UnitMillilux {
    type Output = UnitMillilux;
    #[inline]
    fn sub(self, _: UnitMillilux) -> Self::Output {
        UnitMillilux
    }
}
impl SubAssign<UnitMillilux> for UnitMillilux {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillilux) {}
}
pub struct UnitMilliluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliluxMul {
    #[inline]
    fn clone(&self) -> UnitMilliluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliluxMul {
    #[inline]
    fn eq(&self, other: &UnitMilliluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliluxMul> for i8 {
    type Output = Quantity<i8, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for i16 {
    type Output = Quantity<i16, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for i32 {
    type Output = Quantity<i32, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for i64 {
    type Output = Quantity<i64, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for i128 {
    type Output = Quantity<i128, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for isize {
    type Output = Quantity<isize, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for u8 {
    type Output = Quantity<u8, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for u16 {
    type Output = Quantity<u16, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for u32 {
    type Output = Quantity<u32, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for u64 {
    type Output = Quantity<u64, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for u128 {
    type Output = Quantity<u128, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for usize {
    type Output = Quantity<usize, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for f32 {
    type Output = Quantity<f32, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
impl Mul<UnitMilliluxMul> for f64 {
    type Output = Quantity<f64, UnitMillilux>;
    fn mul(self, _: UnitMilliluxMul) -> Self::Output {
        Quantity::new(self, UnitMillilux)
    }
}
pub struct UnitMicrolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrolux {
    #[inline]
    fn clone(&self) -> UnitMicrolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrolux {
    #[inline]
    fn eq(&self, other: &UnitMicrolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrolux {
    fn default() -> Self {
        UnitMicrolux
    }
}
impl Add<UnitMicrolux> for UnitMicrolux {
    type Output = UnitMicrolux;
    #[inline]
    fn add(self, _: UnitMicrolux) -> Self::Output {
        UnitMicrolux
    }
}
impl AddAssign<UnitMicrolux> for UnitMicrolux {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrolux) {}
}
impl Sub<UnitMicrolux> for UnitMicrolux {
    type Output = UnitMicrolux;
    #[inline]
    fn sub(self, _: UnitMicrolux) -> Self::Output {
        UnitMicrolux
    }
}
impl SubAssign<UnitMicrolux> for UnitMicrolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrolux) {}
}
pub struct UnitMicroluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroluxMul {
    #[inline]
    fn clone(&self) -> UnitMicroluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroluxMul {
    #[inline]
    fn eq(&self, other: &UnitMicroluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroluxMul> for i8 {
    type Output = Quantity<i8, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for i16 {
    type Output = Quantity<i16, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for i32 {
    type Output = Quantity<i32, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for i64 {
    type Output = Quantity<i64, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for i128 {
    type Output = Quantity<i128, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for isize {
    type Output = Quantity<isize, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for u8 {
    type Output = Quantity<u8, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for u16 {
    type Output = Quantity<u16, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for u32 {
    type Output = Quantity<u32, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for u64 {
    type Output = Quantity<u64, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for u128 {
    type Output = Quantity<u128, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for usize {
    type Output = Quantity<usize, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for f32 {
    type Output = Quantity<f32, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
impl Mul<UnitMicroluxMul> for f64 {
    type Output = Quantity<f64, UnitMicrolux>;
    fn mul(self, _: UnitMicroluxMul) -> Self::Output {
        Quantity::new(self, UnitMicrolux)
    }
}
pub struct UnitNanolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanolux {
    #[inline]
    fn clone(&self) -> UnitNanolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanolux {
    #[inline]
    fn eq(&self, other: &UnitNanolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanolux {
    fn default() -> Self {
        UnitNanolux
    }
}
impl Add<UnitNanolux> for UnitNanolux {
    type Output = UnitNanolux;
    #[inline]
    fn add(self, _: UnitNanolux) -> Self::Output {
        UnitNanolux
    }
}
impl AddAssign<UnitNanolux> for UnitNanolux {
    #[inline]
    fn add_assign(&mut self, _: UnitNanolux) {}
}
impl Sub<UnitNanolux> for UnitNanolux {
    type Output = UnitNanolux;
    #[inline]
    fn sub(self, _: UnitNanolux) -> Self::Output {
        UnitNanolux
    }
}
impl SubAssign<UnitNanolux> for UnitNanolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanolux) {}
}
pub struct UnitNanoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoluxMul {
    #[inline]
    fn clone(&self) -> UnitNanoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoluxMul {
    #[inline]
    fn eq(&self, other: &UnitNanoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoluxMul> for i8 {
    type Output = Quantity<i8, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for i16 {
    type Output = Quantity<i16, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for i32 {
    type Output = Quantity<i32, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for i64 {
    type Output = Quantity<i64, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for i128 {
    type Output = Quantity<i128, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for isize {
    type Output = Quantity<isize, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for u8 {
    type Output = Quantity<u8, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for u16 {
    type Output = Quantity<u16, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for u32 {
    type Output = Quantity<u32, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for u64 {
    type Output = Quantity<u64, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for u128 {
    type Output = Quantity<u128, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for usize {
    type Output = Quantity<usize, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for f32 {
    type Output = Quantity<f32, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
impl Mul<UnitNanoluxMul> for f64 {
    type Output = Quantity<f64, UnitNanolux>;
    fn mul(self, _: UnitNanoluxMul) -> Self::Output {
        Quantity::new(self, UnitNanolux)
    }
}
pub struct UnitPicolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicolux {
    #[inline]
    fn clone(&self) -> UnitPicolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicolux {
    #[inline]
    fn eq(&self, other: &UnitPicolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicolux {
    fn default() -> Self {
        UnitPicolux
    }
}
impl Add<UnitPicolux> for UnitPicolux {
    type Output = UnitPicolux;
    #[inline]
    fn add(self, _: UnitPicolux) -> Self::Output {
        UnitPicolux
    }
}
impl AddAssign<UnitPicolux> for UnitPicolux {
    #[inline]
    fn add_assign(&mut self, _: UnitPicolux) {}
}
impl Sub<UnitPicolux> for UnitPicolux {
    type Output = UnitPicolux;
    #[inline]
    fn sub(self, _: UnitPicolux) -> Self::Output {
        UnitPicolux
    }
}
impl SubAssign<UnitPicolux> for UnitPicolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicolux) {}
}
pub struct UnitPicoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoluxMul {
    #[inline]
    fn clone(&self) -> UnitPicoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoluxMul {
    #[inline]
    fn eq(&self, other: &UnitPicoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoluxMul> for i8 {
    type Output = Quantity<i8, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for i16 {
    type Output = Quantity<i16, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for i32 {
    type Output = Quantity<i32, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for i64 {
    type Output = Quantity<i64, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for i128 {
    type Output = Quantity<i128, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for isize {
    type Output = Quantity<isize, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for u8 {
    type Output = Quantity<u8, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for u16 {
    type Output = Quantity<u16, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for u32 {
    type Output = Quantity<u32, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for u64 {
    type Output = Quantity<u64, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for u128 {
    type Output = Quantity<u128, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for usize {
    type Output = Quantity<usize, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for f32 {
    type Output = Quantity<f32, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
impl Mul<UnitPicoluxMul> for f64 {
    type Output = Quantity<f64, UnitPicolux>;
    fn mul(self, _: UnitPicoluxMul) -> Self::Output {
        Quantity::new(self, UnitPicolux)
    }
}
pub struct UnitFemtolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtolux {
    #[inline]
    fn clone(&self) -> UnitFemtolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtolux {
    #[inline]
    fn eq(&self, other: &UnitFemtolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtolux {
    fn default() -> Self {
        UnitFemtolux
    }
}
impl Add<UnitFemtolux> for UnitFemtolux {
    type Output = UnitFemtolux;
    #[inline]
    fn add(self, _: UnitFemtolux) -> Self::Output {
        UnitFemtolux
    }
}
impl AddAssign<UnitFemtolux> for UnitFemtolux {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtolux) {}
}
impl Sub<UnitFemtolux> for UnitFemtolux {
    type Output = UnitFemtolux;
    #[inline]
    fn sub(self, _: UnitFemtolux) -> Self::Output {
        UnitFemtolux
    }
}
impl SubAssign<UnitFemtolux> for UnitFemtolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtolux) {}
}
pub struct UnitFemtoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoluxMul {
    #[inline]
    fn clone(&self) -> UnitFemtoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoluxMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoluxMul> for i8 {
    type Output = Quantity<i8, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for i16 {
    type Output = Quantity<i16, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for i32 {
    type Output = Quantity<i32, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for i64 {
    type Output = Quantity<i64, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for i128 {
    type Output = Quantity<i128, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for isize {
    type Output = Quantity<isize, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for u8 {
    type Output = Quantity<u8, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for u16 {
    type Output = Quantity<u16, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for u32 {
    type Output = Quantity<u32, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for u64 {
    type Output = Quantity<u64, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for u128 {
    type Output = Quantity<u128, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for usize {
    type Output = Quantity<usize, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for f32 {
    type Output = Quantity<f32, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
impl Mul<UnitFemtoluxMul> for f64 {
    type Output = Quantity<f64, UnitFemtolux>;
    fn mul(self, _: UnitFemtoluxMul) -> Self::Output {
        Quantity::new(self, UnitFemtolux)
    }
}
pub struct UnitAttolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttolux {
    #[inline]
    fn clone(&self) -> UnitAttolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttolux {
    #[inline]
    fn eq(&self, other: &UnitAttolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttolux {
    fn default() -> Self {
        UnitAttolux
    }
}
impl Add<UnitAttolux> for UnitAttolux {
    type Output = UnitAttolux;
    #[inline]
    fn add(self, _: UnitAttolux) -> Self::Output {
        UnitAttolux
    }
}
impl AddAssign<UnitAttolux> for UnitAttolux {
    #[inline]
    fn add_assign(&mut self, _: UnitAttolux) {}
}
impl Sub<UnitAttolux> for UnitAttolux {
    type Output = UnitAttolux;
    #[inline]
    fn sub(self, _: UnitAttolux) -> Self::Output {
        UnitAttolux
    }
}
impl SubAssign<UnitAttolux> for UnitAttolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttolux) {}
}
pub struct UnitAttoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoluxMul {
    #[inline]
    fn clone(&self) -> UnitAttoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoluxMul {
    #[inline]
    fn eq(&self, other: &UnitAttoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoluxMul> for i8 {
    type Output = Quantity<i8, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for i16 {
    type Output = Quantity<i16, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for i32 {
    type Output = Quantity<i32, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for i64 {
    type Output = Quantity<i64, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for i128 {
    type Output = Quantity<i128, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for isize {
    type Output = Quantity<isize, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for u8 {
    type Output = Quantity<u8, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for u16 {
    type Output = Quantity<u16, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for u32 {
    type Output = Quantity<u32, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for u64 {
    type Output = Quantity<u64, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for u128 {
    type Output = Quantity<u128, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for usize {
    type Output = Quantity<usize, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for f32 {
    type Output = Quantity<f32, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
impl Mul<UnitAttoluxMul> for f64 {
    type Output = Quantity<f64, UnitAttolux>;
    fn mul(self, _: UnitAttoluxMul) -> Self::Output {
        Quantity::new(self, UnitAttolux)
    }
}
pub struct UnitZeptolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptolux {
    #[inline]
    fn clone(&self) -> UnitZeptolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptolux {
    #[inline]
    fn eq(&self, other: &UnitZeptolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptolux {
    fn default() -> Self {
        UnitZeptolux
    }
}
impl Add<UnitZeptolux> for UnitZeptolux {
    type Output = UnitZeptolux;
    #[inline]
    fn add(self, _: UnitZeptolux) -> Self::Output {
        UnitZeptolux
    }
}
impl AddAssign<UnitZeptolux> for UnitZeptolux {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptolux) {}
}
impl Sub<UnitZeptolux> for UnitZeptolux {
    type Output = UnitZeptolux;
    #[inline]
    fn sub(self, _: UnitZeptolux) -> Self::Output {
        UnitZeptolux
    }
}
impl SubAssign<UnitZeptolux> for UnitZeptolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptolux) {}
}
pub struct UnitZeptoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoluxMul {
    #[inline]
    fn clone(&self) -> UnitZeptoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoluxMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoluxMul> for i8 {
    type Output = Quantity<i8, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for i16 {
    type Output = Quantity<i16, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for i32 {
    type Output = Quantity<i32, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for i64 {
    type Output = Quantity<i64, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for i128 {
    type Output = Quantity<i128, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for isize {
    type Output = Quantity<isize, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for u8 {
    type Output = Quantity<u8, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for u16 {
    type Output = Quantity<u16, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for u32 {
    type Output = Quantity<u32, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for u64 {
    type Output = Quantity<u64, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for u128 {
    type Output = Quantity<u128, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for usize {
    type Output = Quantity<usize, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for f32 {
    type Output = Quantity<f32, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
impl Mul<UnitZeptoluxMul> for f64 {
    type Output = Quantity<f64, UnitZeptolux>;
    fn mul(self, _: UnitZeptoluxMul) -> Self::Output {
        Quantity::new(self, UnitZeptolux)
    }
}
pub struct UnitYoctolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctolux {
    #[inline]
    fn clone(&self) -> UnitYoctolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctolux {
    #[inline]
    fn eq(&self, other: &UnitYoctolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctolux {
    fn default() -> Self {
        UnitYoctolux
    }
}
impl Add<UnitYoctolux> for UnitYoctolux {
    type Output = UnitYoctolux;
    #[inline]
    fn add(self, _: UnitYoctolux) -> Self::Output {
        UnitYoctolux
    }
}
impl AddAssign<UnitYoctolux> for UnitYoctolux {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctolux) {}
}
impl Sub<UnitYoctolux> for UnitYoctolux {
    type Output = UnitYoctolux;
    #[inline]
    fn sub(self, _: UnitYoctolux) -> Self::Output {
        UnitYoctolux
    }
}
impl SubAssign<UnitYoctolux> for UnitYoctolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctolux) {}
}
pub struct UnitYoctoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoluxMul {
    #[inline]
    fn clone(&self) -> UnitYoctoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoluxMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoluxMul> for i8 {
    type Output = Quantity<i8, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for i16 {
    type Output = Quantity<i16, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for i32 {
    type Output = Quantity<i32, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for i64 {
    type Output = Quantity<i64, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for i128 {
    type Output = Quantity<i128, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for isize {
    type Output = Quantity<isize, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for u8 {
    type Output = Quantity<u8, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for u16 {
    type Output = Quantity<u16, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for u32 {
    type Output = Quantity<u32, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for u64 {
    type Output = Quantity<u64, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for u128 {
    type Output = Quantity<u128, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for usize {
    type Output = Quantity<usize, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for f32 {
    type Output = Quantity<f32, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
impl Mul<UnitYoctoluxMul> for f64 {
    type Output = Quantity<f64, UnitYoctolux>;
    fn mul(self, _: UnitYoctoluxMul) -> Self::Output {
        Quantity::new(self, UnitYoctolux)
    }
}
pub struct UnitRontolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontolux {
    #[inline]
    fn clone(&self) -> UnitRontolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontolux {
    #[inline]
    fn eq(&self, other: &UnitRontolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontolux {
    fn default() -> Self {
        UnitRontolux
    }
}
impl Add<UnitRontolux> for UnitRontolux {
    type Output = UnitRontolux;
    #[inline]
    fn add(self, _: UnitRontolux) -> Self::Output {
        UnitRontolux
    }
}
impl AddAssign<UnitRontolux> for UnitRontolux {
    #[inline]
    fn add_assign(&mut self, _: UnitRontolux) {}
}
impl Sub<UnitRontolux> for UnitRontolux {
    type Output = UnitRontolux;
    #[inline]
    fn sub(self, _: UnitRontolux) -> Self::Output {
        UnitRontolux
    }
}
impl SubAssign<UnitRontolux> for UnitRontolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontolux) {}
}
pub struct UnitRontoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoluxMul {
    #[inline]
    fn clone(&self) -> UnitRontoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoluxMul {
    #[inline]
    fn eq(&self, other: &UnitRontoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoluxMul> for i8 {
    type Output = Quantity<i8, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for i16 {
    type Output = Quantity<i16, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for i32 {
    type Output = Quantity<i32, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for i64 {
    type Output = Quantity<i64, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for i128 {
    type Output = Quantity<i128, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for isize {
    type Output = Quantity<isize, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for u8 {
    type Output = Quantity<u8, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for u16 {
    type Output = Quantity<u16, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for u32 {
    type Output = Quantity<u32, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for u64 {
    type Output = Quantity<u64, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for u128 {
    type Output = Quantity<u128, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for usize {
    type Output = Quantity<usize, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for f32 {
    type Output = Quantity<f32, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
impl Mul<UnitRontoluxMul> for f64 {
    type Output = Quantity<f64, UnitRontolux>;
    fn mul(self, _: UnitRontoluxMul) -> Self::Output {
        Quantity::new(self, UnitRontolux)
    }
}
pub struct UnitQuectolux;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectolux {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectolux")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectolux {
    #[inline]
    fn clone(&self) -> UnitQuectolux {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectolux {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectolux {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectolux {
    #[inline]
    fn eq(&self, other: &UnitQuectolux) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectolux {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectolux {
    fn default() -> Self {
        UnitQuectolux
    }
}
impl Add<UnitQuectolux> for UnitQuectolux {
    type Output = UnitQuectolux;
    #[inline]
    fn add(self, _: UnitQuectolux) -> Self::Output {
        UnitQuectolux
    }
}
impl AddAssign<UnitQuectolux> for UnitQuectolux {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectolux) {}
}
impl Sub<UnitQuectolux> for UnitQuectolux {
    type Output = UnitQuectolux;
    #[inline]
    fn sub(self, _: UnitQuectolux) -> Self::Output {
        UnitQuectolux
    }
}
impl SubAssign<UnitQuectolux> for UnitQuectolux {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectolux) {}
}
pub struct UnitQuectoluxMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoluxMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoluxMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoluxMul {
    #[inline]
    fn clone(&self) -> UnitQuectoluxMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoluxMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoluxMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoluxMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoluxMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoluxMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoluxMul> for i8 {
    type Output = Quantity<i8, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for i16 {
    type Output = Quantity<i16, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for i32 {
    type Output = Quantity<i32, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for i64 {
    type Output = Quantity<i64, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for i128 {
    type Output = Quantity<i128, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for isize {
    type Output = Quantity<isize, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for u8 {
    type Output = Quantity<u8, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for u16 {
    type Output = Quantity<u16, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for u32 {
    type Output = Quantity<u32, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for u64 {
    type Output = Quantity<u64, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for u128 {
    type Output = Quantity<u128, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for usize {
    type Output = Quantity<usize, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for f32 {
    type Output = Quantity<f32, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
impl Mul<UnitQuectoluxMul> for f64 {
    type Output = Quantity<f64, UnitQuectolux>;
    fn mul(self, _: UnitQuectoluxMul) -> Self::Output {
        Quantity::new(self, UnitQuectolux)
    }
}
pub type Lux<T> = Quantity<T, UnitLux>;
#[allow(non_upper_case_globals)]
pub static Lux: UnitLuxMul = UnitLuxMul;
pub type Quettalux<T> = Quantity<T, UnitQuettalux>;
#[allow(non_upper_case_globals)]
pub static Quettalux: UnitQuettaluxMul = UnitQuettaluxMul;
pub type Ronnalux<T> = Quantity<T, UnitRonnalux>;
#[allow(non_upper_case_globals)]
pub static Ronnalux: UnitRonnaluxMul = UnitRonnaluxMul;
pub type Yottalux<T> = Quantity<T, UnitYottalux>;
#[allow(non_upper_case_globals)]
pub static Yottalux: UnitYottaluxMul = UnitYottaluxMul;
pub type Zettalux<T> = Quantity<T, UnitZettalux>;
#[allow(non_upper_case_globals)]
pub static Zettalux: UnitZettaluxMul = UnitZettaluxMul;
pub type Exalux<T> = Quantity<T, UnitExalux>;
#[allow(non_upper_case_globals)]
pub static Exalux: UnitExaluxMul = UnitExaluxMul;
pub type Petalux<T> = Quantity<T, UnitPetalux>;
#[allow(non_upper_case_globals)]
pub static Petalux: UnitPetaluxMul = UnitPetaluxMul;
pub type Teralux<T> = Quantity<T, UnitTeralux>;
#[allow(non_upper_case_globals)]
pub static Teralux: UnitTeraluxMul = UnitTeraluxMul;
pub type Gigalux<T> = Quantity<T, UnitGigalux>;
#[allow(non_upper_case_globals)]
pub static Gigalux: UnitGigaluxMul = UnitGigaluxMul;
pub type Megalux<T> = Quantity<T, UnitMegalux>;
#[allow(non_upper_case_globals)]
pub static Megalux: UnitMegaluxMul = UnitMegaluxMul;
pub type Kilolux<T> = Quantity<T, UnitKilolux>;
#[allow(non_upper_case_globals)]
pub static Kilolux: UnitKiloluxMul = UnitKiloluxMul;
pub type Hectolux<T> = Quantity<T, UnitHectolux>;
#[allow(non_upper_case_globals)]
pub static Hectolux: UnitHectoluxMul = UnitHectoluxMul;
pub type Decalux<T> = Quantity<T, UnitDecalux>;
#[allow(non_upper_case_globals)]
pub static Decalux: UnitDecaluxMul = UnitDecaluxMul;
pub type Decilux<T> = Quantity<T, UnitDecilux>;
#[allow(non_upper_case_globals)]
pub static Decilux: UnitDeciluxMul = UnitDeciluxMul;
pub type Centilux<T> = Quantity<T, UnitCentilux>;
#[allow(non_upper_case_globals)]
pub static Centilux: UnitCentiluxMul = UnitCentiluxMul;
pub type Millilux<T> = Quantity<T, UnitMillilux>;
#[allow(non_upper_case_globals)]
pub static Millilux: UnitMilliluxMul = UnitMilliluxMul;
pub type Microlux<T> = Quantity<T, UnitMicrolux>;
#[allow(non_upper_case_globals)]
pub static Microlux: UnitMicroluxMul = UnitMicroluxMul;
pub type Nanolux<T> = Quantity<T, UnitNanolux>;
#[allow(non_upper_case_globals)]
pub static Nanolux: UnitNanoluxMul = UnitNanoluxMul;
pub type Picolux<T> = Quantity<T, UnitPicolux>;
#[allow(non_upper_case_globals)]
pub static Picolux: UnitPicoluxMul = UnitPicoluxMul;
pub type Femtolux<T> = Quantity<T, UnitFemtolux>;
#[allow(non_upper_case_globals)]
pub static Femtolux: UnitFemtoluxMul = UnitFemtoluxMul;
pub type Attolux<T> = Quantity<T, UnitAttolux>;
#[allow(non_upper_case_globals)]
pub static Attolux: UnitAttoluxMul = UnitAttoluxMul;
pub type Zeptolux<T> = Quantity<T, UnitZeptolux>;
#[allow(non_upper_case_globals)]
pub static Zeptolux: UnitZeptoluxMul = UnitZeptoluxMul;
pub type Yoctolux<T> = Quantity<T, UnitYoctolux>;
#[allow(non_upper_case_globals)]
pub static Yoctolux: UnitYoctoluxMul = UnitYoctoluxMul;
pub type Rontolux<T> = Quantity<T, UnitRontolux>;
#[allow(non_upper_case_globals)]
pub static Rontolux: UnitRontoluxMul = UnitRontoluxMul;
pub type Quectolux<T> = Quantity<T, UnitQuectolux>;
#[allow(non_upper_case_globals)]
pub static Quectolux: UnitQuectoluxMul = UnitQuectoluxMul;
pub struct UnitBecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitBecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitBecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitBecquerels {
    #[inline]
    fn clone(&self) -> UnitBecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitBecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitBecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitBecquerels {
    #[inline]
    fn eq(&self, other: &UnitBecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitBecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitBecquerels {
    fn default() -> Self {
        UnitBecquerels
    }
}
impl Add<UnitBecquerels> for UnitBecquerels {
    type Output = UnitBecquerels;
    #[inline]
    fn add(self, _: UnitBecquerels) -> Self::Output {
        UnitBecquerels
    }
}
impl AddAssign<UnitBecquerels> for UnitBecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitBecquerels) {}
}
impl Sub<UnitBecquerels> for UnitBecquerels {
    type Output = UnitBecquerels;
    #[inline]
    fn sub(self, _: UnitBecquerels) -> Self::Output {
        UnitBecquerels
    }
}
impl SubAssign<UnitBecquerels> for UnitBecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitBecquerels) {}
}
pub struct UnitBecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitBecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitBecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitBecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitBecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitBecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitBecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitBecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitBecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitBecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitBecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for isize {
    type Output = Quantity<isize, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for usize {
    type Output = Quantity<usize, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
impl Mul<UnitBecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitBecquerels>;
    fn mul(self, _: UnitBecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitBecquerels)
    }
}
pub struct UnitQuettabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettabecquerels {
    #[inline]
    fn clone(&self) -> UnitQuettabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettabecquerels {
    #[inline]
    fn eq(&self, other: &UnitQuettabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettabecquerels {
    fn default() -> Self {
        UnitQuettabecquerels
    }
}
impl Add<UnitQuettabecquerels> for UnitQuettabecquerels {
    type Output = UnitQuettabecquerels;
    #[inline]
    fn add(self, _: UnitQuettabecquerels) -> Self::Output {
        UnitQuettabecquerels
    }
}
impl AddAssign<UnitQuettabecquerels> for UnitQuettabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettabecquerels) {}
}
impl Sub<UnitQuettabecquerels> for UnitQuettabecquerels {
    type Output = UnitQuettabecquerels;
    #[inline]
    fn sub(self, _: UnitQuettabecquerels) -> Self::Output {
        UnitQuettabecquerels
    }
}
impl SubAssign<UnitQuettabecquerels> for UnitQuettabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettabecquerels) {}
}
pub struct UnitQuettabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitQuettabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
impl Mul<UnitQuettabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitQuettabecquerels>;
    fn mul(self, _: UnitQuettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuettabecquerels)
    }
}
pub struct UnitRonnabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnabecquerels {
    #[inline]
    fn clone(&self) -> UnitRonnabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnabecquerels {
    #[inline]
    fn eq(&self, other: &UnitRonnabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnabecquerels {
    fn default() -> Self {
        UnitRonnabecquerels
    }
}
impl Add<UnitRonnabecquerels> for UnitRonnabecquerels {
    type Output = UnitRonnabecquerels;
    #[inline]
    fn add(self, _: UnitRonnabecquerels) -> Self::Output {
        UnitRonnabecquerels
    }
}
impl AddAssign<UnitRonnabecquerels> for UnitRonnabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnabecquerels) {}
}
impl Sub<UnitRonnabecquerels> for UnitRonnabecquerels {
    type Output = UnitRonnabecquerels;
    #[inline]
    fn sub(self, _: UnitRonnabecquerels) -> Self::Output {
        UnitRonnabecquerels
    }
}
impl SubAssign<UnitRonnabecquerels> for UnitRonnabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnabecquerels) {}
}
pub struct UnitRonnabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitRonnabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
impl Mul<UnitRonnabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitRonnabecquerels>;
    fn mul(self, _: UnitRonnabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRonnabecquerels)
    }
}
pub struct UnitYottabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottabecquerels {
    #[inline]
    fn clone(&self) -> UnitYottabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottabecquerels {
    #[inline]
    fn eq(&self, other: &UnitYottabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottabecquerels {
    fn default() -> Self {
        UnitYottabecquerels
    }
}
impl Add<UnitYottabecquerels> for UnitYottabecquerels {
    type Output = UnitYottabecquerels;
    #[inline]
    fn add(self, _: UnitYottabecquerels) -> Self::Output {
        UnitYottabecquerels
    }
}
impl AddAssign<UnitYottabecquerels> for UnitYottabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitYottabecquerels) {}
}
impl Sub<UnitYottabecquerels> for UnitYottabecquerels {
    type Output = UnitYottabecquerels;
    #[inline]
    fn sub(self, _: UnitYottabecquerels) -> Self::Output {
        UnitYottabecquerels
    }
}
impl SubAssign<UnitYottabecquerels> for UnitYottabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottabecquerels) {}
}
pub struct UnitYottabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitYottabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitYottabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
impl Mul<UnitYottabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitYottabecquerels>;
    fn mul(self, _: UnitYottabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYottabecquerels)
    }
}
pub struct UnitZettabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettabecquerels {
    #[inline]
    fn clone(&self) -> UnitZettabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettabecquerels {
    #[inline]
    fn eq(&self, other: &UnitZettabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettabecquerels {
    fn default() -> Self {
        UnitZettabecquerels
    }
}
impl Add<UnitZettabecquerels> for UnitZettabecquerels {
    type Output = UnitZettabecquerels;
    #[inline]
    fn add(self, _: UnitZettabecquerels) -> Self::Output {
        UnitZettabecquerels
    }
}
impl AddAssign<UnitZettabecquerels> for UnitZettabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitZettabecquerels) {}
}
impl Sub<UnitZettabecquerels> for UnitZettabecquerels {
    type Output = UnitZettabecquerels;
    #[inline]
    fn sub(self, _: UnitZettabecquerels) -> Self::Output {
        UnitZettabecquerels
    }
}
impl SubAssign<UnitZettabecquerels> for UnitZettabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettabecquerels) {}
}
pub struct UnitZettabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitZettabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitZettabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
impl Mul<UnitZettabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitZettabecquerels>;
    fn mul(self, _: UnitZettabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZettabecquerels)
    }
}
pub struct UnitExabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExabecquerels {
    #[inline]
    fn clone(&self) -> UnitExabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExabecquerels {
    #[inline]
    fn eq(&self, other: &UnitExabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExabecquerels {
    fn default() -> Self {
        UnitExabecquerels
    }
}
impl Add<UnitExabecquerels> for UnitExabecquerels {
    type Output = UnitExabecquerels;
    #[inline]
    fn add(self, _: UnitExabecquerels) -> Self::Output {
        UnitExabecquerels
    }
}
impl AddAssign<UnitExabecquerels> for UnitExabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitExabecquerels) {}
}
impl Sub<UnitExabecquerels> for UnitExabecquerels {
    type Output = UnitExabecquerels;
    #[inline]
    fn sub(self, _: UnitExabecquerels) -> Self::Output {
        UnitExabecquerels
    }
}
impl SubAssign<UnitExabecquerels> for UnitExabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitExabecquerels) {}
}
pub struct UnitExabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitExabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitExabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
impl Mul<UnitExabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitExabecquerels>;
    fn mul(self, _: UnitExabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitExabecquerels)
    }
}
pub struct UnitPetabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetabecquerels {
    #[inline]
    fn clone(&self) -> UnitPetabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetabecquerels {
    #[inline]
    fn eq(&self, other: &UnitPetabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetabecquerels {
    fn default() -> Self {
        UnitPetabecquerels
    }
}
impl Add<UnitPetabecquerels> for UnitPetabecquerels {
    type Output = UnitPetabecquerels;
    #[inline]
    fn add(self, _: UnitPetabecquerels) -> Self::Output {
        UnitPetabecquerels
    }
}
impl AddAssign<UnitPetabecquerels> for UnitPetabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitPetabecquerels) {}
}
impl Sub<UnitPetabecquerels> for UnitPetabecquerels {
    type Output = UnitPetabecquerels;
    #[inline]
    fn sub(self, _: UnitPetabecquerels) -> Self::Output {
        UnitPetabecquerels
    }
}
impl SubAssign<UnitPetabecquerels> for UnitPetabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetabecquerels) {}
}
pub struct UnitPetabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitPetabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitPetabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
impl Mul<UnitPetabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitPetabecquerels>;
    fn mul(self, _: UnitPetabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPetabecquerels)
    }
}
pub struct UnitTerabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerabecquerels {
    #[inline]
    fn clone(&self) -> UnitTerabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerabecquerels {
    #[inline]
    fn eq(&self, other: &UnitTerabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerabecquerels {
    fn default() -> Self {
        UnitTerabecquerels
    }
}
impl Add<UnitTerabecquerels> for UnitTerabecquerels {
    type Output = UnitTerabecquerels;
    #[inline]
    fn add(self, _: UnitTerabecquerels) -> Self::Output {
        UnitTerabecquerels
    }
}
impl AddAssign<UnitTerabecquerels> for UnitTerabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitTerabecquerels) {}
}
impl Sub<UnitTerabecquerels> for UnitTerabecquerels {
    type Output = UnitTerabecquerels;
    #[inline]
    fn sub(self, _: UnitTerabecquerels) -> Self::Output {
        UnitTerabecquerels
    }
}
impl SubAssign<UnitTerabecquerels> for UnitTerabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerabecquerels) {}
}
pub struct UnitTerabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitTerabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitTerabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
impl Mul<UnitTerabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitTerabecquerels>;
    fn mul(self, _: UnitTerabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitTerabecquerels)
    }
}
pub struct UnitGigabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigabecquerels {
    #[inline]
    fn clone(&self) -> UnitGigabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigabecquerels {
    #[inline]
    fn eq(&self, other: &UnitGigabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigabecquerels {
    fn default() -> Self {
        UnitGigabecquerels
    }
}
impl Add<UnitGigabecquerels> for UnitGigabecquerels {
    type Output = UnitGigabecquerels;
    #[inline]
    fn add(self, _: UnitGigabecquerels) -> Self::Output {
        UnitGigabecquerels
    }
}
impl AddAssign<UnitGigabecquerels> for UnitGigabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitGigabecquerels) {}
}
impl Sub<UnitGigabecquerels> for UnitGigabecquerels {
    type Output = UnitGigabecquerels;
    #[inline]
    fn sub(self, _: UnitGigabecquerels) -> Self::Output {
        UnitGigabecquerels
    }
}
impl SubAssign<UnitGigabecquerels> for UnitGigabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigabecquerels) {}
}
pub struct UnitGigabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitGigabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitGigabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
impl Mul<UnitGigabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitGigabecquerels>;
    fn mul(self, _: UnitGigabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitGigabecquerels)
    }
}
pub struct UnitMegabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegabecquerels {
    #[inline]
    fn clone(&self) -> UnitMegabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegabecquerels {
    #[inline]
    fn eq(&self, other: &UnitMegabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegabecquerels {
    fn default() -> Self {
        UnitMegabecquerels
    }
}
impl Add<UnitMegabecquerels> for UnitMegabecquerels {
    type Output = UnitMegabecquerels;
    #[inline]
    fn add(self, _: UnitMegabecquerels) -> Self::Output {
        UnitMegabecquerels
    }
}
impl AddAssign<UnitMegabecquerels> for UnitMegabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitMegabecquerels) {}
}
impl Sub<UnitMegabecquerels> for UnitMegabecquerels {
    type Output = UnitMegabecquerels;
    #[inline]
    fn sub(self, _: UnitMegabecquerels) -> Self::Output {
        UnitMegabecquerels
    }
}
impl SubAssign<UnitMegabecquerels> for UnitMegabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegabecquerels) {}
}
pub struct UnitMegabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitMegabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitMegabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
impl Mul<UnitMegabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitMegabecquerels>;
    fn mul(self, _: UnitMegabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMegabecquerels)
    }
}
pub struct UnitKilobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilobecquerels {
    #[inline]
    fn clone(&self) -> UnitKilobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilobecquerels {
    #[inline]
    fn eq(&self, other: &UnitKilobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilobecquerels {
    fn default() -> Self {
        UnitKilobecquerels
    }
}
impl Add<UnitKilobecquerels> for UnitKilobecquerels {
    type Output = UnitKilobecquerels;
    #[inline]
    fn add(self, _: UnitKilobecquerels) -> Self::Output {
        UnitKilobecquerels
    }
}
impl AddAssign<UnitKilobecquerels> for UnitKilobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitKilobecquerels) {}
}
impl Sub<UnitKilobecquerels> for UnitKilobecquerels {
    type Output = UnitKilobecquerels;
    #[inline]
    fn sub(self, _: UnitKilobecquerels) -> Self::Output {
        UnitKilobecquerels
    }
}
impl SubAssign<UnitKilobecquerels> for UnitKilobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilobecquerels) {}
}
pub struct UnitKilobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitKilobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitKilobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
impl Mul<UnitKilobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitKilobecquerels>;
    fn mul(self, _: UnitKilobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitKilobecquerels)
    }
}
pub struct UnitHectobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectobecquerels {
    #[inline]
    fn clone(&self) -> UnitHectobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectobecquerels {
    #[inline]
    fn eq(&self, other: &UnitHectobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectobecquerels {
    fn default() -> Self {
        UnitHectobecquerels
    }
}
impl Add<UnitHectobecquerels> for UnitHectobecquerels {
    type Output = UnitHectobecquerels;
    #[inline]
    fn add(self, _: UnitHectobecquerels) -> Self::Output {
        UnitHectobecquerels
    }
}
impl AddAssign<UnitHectobecquerels> for UnitHectobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitHectobecquerels) {}
}
impl Sub<UnitHectobecquerels> for UnitHectobecquerels {
    type Output = UnitHectobecquerels;
    #[inline]
    fn sub(self, _: UnitHectobecquerels) -> Self::Output {
        UnitHectobecquerels
    }
}
impl SubAssign<UnitHectobecquerels> for UnitHectobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectobecquerels) {}
}
pub struct UnitHectobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitHectobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitHectobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
impl Mul<UnitHectobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitHectobecquerels>;
    fn mul(self, _: UnitHectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitHectobecquerels)
    }
}
pub struct UnitDecabecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecabecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecabecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecabecquerels {
    #[inline]
    fn clone(&self) -> UnitDecabecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecabecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecabecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecabecquerels {
    #[inline]
    fn eq(&self, other: &UnitDecabecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecabecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecabecquerels {
    fn default() -> Self {
        UnitDecabecquerels
    }
}
impl Add<UnitDecabecquerels> for UnitDecabecquerels {
    type Output = UnitDecabecquerels;
    #[inline]
    fn add(self, _: UnitDecabecquerels) -> Self::Output {
        UnitDecabecquerels
    }
}
impl AddAssign<UnitDecabecquerels> for UnitDecabecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitDecabecquerels) {}
}
impl Sub<UnitDecabecquerels> for UnitDecabecquerels {
    type Output = UnitDecabecquerels;
    #[inline]
    fn sub(self, _: UnitDecabecquerels) -> Self::Output {
        UnitDecabecquerels
    }
}
impl SubAssign<UnitDecabecquerels> for UnitDecabecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecabecquerels) {}
}
pub struct UnitDecabecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecabecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecabecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecabecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitDecabecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecabecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecabecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecabecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitDecabecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecabecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecabecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for isize {
    type Output = Quantity<isize, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for usize {
    type Output = Quantity<usize, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
impl Mul<UnitDecabecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitDecabecquerels>;
    fn mul(self, _: UnitDecabecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecabecquerels)
    }
}
pub struct UnitDecibecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecibecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecibecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecibecquerels {
    #[inline]
    fn clone(&self) -> UnitDecibecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecibecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecibecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecibecquerels {
    #[inline]
    fn eq(&self, other: &UnitDecibecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecibecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecibecquerels {
    fn default() -> Self {
        UnitDecibecquerels
    }
}
impl Add<UnitDecibecquerels> for UnitDecibecquerels {
    type Output = UnitDecibecquerels;
    #[inline]
    fn add(self, _: UnitDecibecquerels) -> Self::Output {
        UnitDecibecquerels
    }
}
impl AddAssign<UnitDecibecquerels> for UnitDecibecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitDecibecquerels) {}
}
impl Sub<UnitDecibecquerels> for UnitDecibecquerels {
    type Output = UnitDecibecquerels;
    #[inline]
    fn sub(self, _: UnitDecibecquerels) -> Self::Output {
        UnitDecibecquerels
    }
}
impl SubAssign<UnitDecibecquerels> for UnitDecibecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecibecquerels) {}
}
pub struct UnitDecibecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecibecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecibecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecibecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitDecibecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecibecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecibecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecibecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitDecibecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecibecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecibecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for isize {
    type Output = Quantity<isize, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for usize {
    type Output = Quantity<usize, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
impl Mul<UnitDecibecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitDecibecquerels>;
    fn mul(self, _: UnitDecibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitDecibecquerels)
    }
}
pub struct UnitCentibecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentibecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentibecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentibecquerels {
    #[inline]
    fn clone(&self) -> UnitCentibecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentibecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentibecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentibecquerels {
    #[inline]
    fn eq(&self, other: &UnitCentibecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentibecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentibecquerels {
    fn default() -> Self {
        UnitCentibecquerels
    }
}
impl Add<UnitCentibecquerels> for UnitCentibecquerels {
    type Output = UnitCentibecquerels;
    #[inline]
    fn add(self, _: UnitCentibecquerels) -> Self::Output {
        UnitCentibecquerels
    }
}
impl AddAssign<UnitCentibecquerels> for UnitCentibecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitCentibecquerels) {}
}
impl Sub<UnitCentibecquerels> for UnitCentibecquerels {
    type Output = UnitCentibecquerels;
    #[inline]
    fn sub(self, _: UnitCentibecquerels) -> Self::Output {
        UnitCentibecquerels
    }
}
impl SubAssign<UnitCentibecquerels> for UnitCentibecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentibecquerels) {}
}
pub struct UnitCentibecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentibecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentibecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentibecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitCentibecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentibecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentibecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentibecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitCentibecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentibecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentibecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for isize {
    type Output = Quantity<isize, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for usize {
    type Output = Quantity<usize, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
impl Mul<UnitCentibecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitCentibecquerels>;
    fn mul(self, _: UnitCentibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitCentibecquerels)
    }
}
pub struct UnitMillibecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillibecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillibecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillibecquerels {
    #[inline]
    fn clone(&self) -> UnitMillibecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillibecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillibecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillibecquerels {
    #[inline]
    fn eq(&self, other: &UnitMillibecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillibecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillibecquerels {
    fn default() -> Self {
        UnitMillibecquerels
    }
}
impl Add<UnitMillibecquerels> for UnitMillibecquerels {
    type Output = UnitMillibecquerels;
    #[inline]
    fn add(self, _: UnitMillibecquerels) -> Self::Output {
        UnitMillibecquerels
    }
}
impl AddAssign<UnitMillibecquerels> for UnitMillibecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitMillibecquerels) {}
}
impl Sub<UnitMillibecquerels> for UnitMillibecquerels {
    type Output = UnitMillibecquerels;
    #[inline]
    fn sub(self, _: UnitMillibecquerels) -> Self::Output {
        UnitMillibecquerels
    }
}
impl SubAssign<UnitMillibecquerels> for UnitMillibecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillibecquerels) {}
}
pub struct UnitMillibecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillibecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillibecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillibecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitMillibecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillibecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillibecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillibecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitMillibecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillibecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillibecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for isize {
    type Output = Quantity<isize, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for usize {
    type Output = Quantity<usize, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
impl Mul<UnitMillibecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitMillibecquerels>;
    fn mul(self, _: UnitMillibecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMillibecquerels)
    }
}
pub struct UnitMicrobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrobecquerels {
    #[inline]
    fn clone(&self) -> UnitMicrobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrobecquerels {
    #[inline]
    fn eq(&self, other: &UnitMicrobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrobecquerels {
    fn default() -> Self {
        UnitMicrobecquerels
    }
}
impl Add<UnitMicrobecquerels> for UnitMicrobecquerels {
    type Output = UnitMicrobecquerels;
    #[inline]
    fn add(self, _: UnitMicrobecquerels) -> Self::Output {
        UnitMicrobecquerels
    }
}
impl AddAssign<UnitMicrobecquerels> for UnitMicrobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrobecquerels) {}
}
impl Sub<UnitMicrobecquerels> for UnitMicrobecquerels {
    type Output = UnitMicrobecquerels;
    #[inline]
    fn sub(self, _: UnitMicrobecquerels) -> Self::Output {
        UnitMicrobecquerels
    }
}
impl SubAssign<UnitMicrobecquerels> for UnitMicrobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrobecquerels) {}
}
pub struct UnitMicrobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitMicrobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
impl Mul<UnitMicrobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitMicrobecquerels>;
    fn mul(self, _: UnitMicrobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitMicrobecquerels)
    }
}
pub struct UnitNanobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanobecquerels {
    #[inline]
    fn clone(&self) -> UnitNanobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanobecquerels {
    #[inline]
    fn eq(&self, other: &UnitNanobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanobecquerels {
    fn default() -> Self {
        UnitNanobecquerels
    }
}
impl Add<UnitNanobecquerels> for UnitNanobecquerels {
    type Output = UnitNanobecquerels;
    #[inline]
    fn add(self, _: UnitNanobecquerels) -> Self::Output {
        UnitNanobecquerels
    }
}
impl AddAssign<UnitNanobecquerels> for UnitNanobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitNanobecquerels) {}
}
impl Sub<UnitNanobecquerels> for UnitNanobecquerels {
    type Output = UnitNanobecquerels;
    #[inline]
    fn sub(self, _: UnitNanobecquerels) -> Self::Output {
        UnitNanobecquerels
    }
}
impl SubAssign<UnitNanobecquerels> for UnitNanobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanobecquerels) {}
}
pub struct UnitNanobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitNanobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitNanobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
impl Mul<UnitNanobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitNanobecquerels>;
    fn mul(self, _: UnitNanobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitNanobecquerels)
    }
}
pub struct UnitPicobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicobecquerels {
    #[inline]
    fn clone(&self) -> UnitPicobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicobecquerels {
    #[inline]
    fn eq(&self, other: &UnitPicobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicobecquerels {
    fn default() -> Self {
        UnitPicobecquerels
    }
}
impl Add<UnitPicobecquerels> for UnitPicobecquerels {
    type Output = UnitPicobecquerels;
    #[inline]
    fn add(self, _: UnitPicobecquerels) -> Self::Output {
        UnitPicobecquerels
    }
}
impl AddAssign<UnitPicobecquerels> for UnitPicobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitPicobecquerels) {}
}
impl Sub<UnitPicobecquerels> for UnitPicobecquerels {
    type Output = UnitPicobecquerels;
    #[inline]
    fn sub(self, _: UnitPicobecquerels) -> Self::Output {
        UnitPicobecquerels
    }
}
impl SubAssign<UnitPicobecquerels> for UnitPicobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicobecquerels) {}
}
pub struct UnitPicobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitPicobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitPicobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
impl Mul<UnitPicobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitPicobecquerels>;
    fn mul(self, _: UnitPicobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitPicobecquerels)
    }
}
pub struct UnitFemtobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtobecquerels {
    #[inline]
    fn clone(&self) -> UnitFemtobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtobecquerels {
    #[inline]
    fn eq(&self, other: &UnitFemtobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtobecquerels {
    fn default() -> Self {
        UnitFemtobecquerels
    }
}
impl Add<UnitFemtobecquerels> for UnitFemtobecquerels {
    type Output = UnitFemtobecquerels;
    #[inline]
    fn add(self, _: UnitFemtobecquerels) -> Self::Output {
        UnitFemtobecquerels
    }
}
impl AddAssign<UnitFemtobecquerels> for UnitFemtobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtobecquerels) {}
}
impl Sub<UnitFemtobecquerels> for UnitFemtobecquerels {
    type Output = UnitFemtobecquerels;
    #[inline]
    fn sub(self, _: UnitFemtobecquerels) -> Self::Output {
        UnitFemtobecquerels
    }
}
impl SubAssign<UnitFemtobecquerels> for UnitFemtobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtobecquerels) {}
}
pub struct UnitFemtobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitFemtobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
impl Mul<UnitFemtobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitFemtobecquerels>;
    fn mul(self, _: UnitFemtobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitFemtobecquerels)
    }
}
pub struct UnitAttobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttobecquerels {
    #[inline]
    fn clone(&self) -> UnitAttobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttobecquerels {
    #[inline]
    fn eq(&self, other: &UnitAttobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttobecquerels {
    fn default() -> Self {
        UnitAttobecquerels
    }
}
impl Add<UnitAttobecquerels> for UnitAttobecquerels {
    type Output = UnitAttobecquerels;
    #[inline]
    fn add(self, _: UnitAttobecquerels) -> Self::Output {
        UnitAttobecquerels
    }
}
impl AddAssign<UnitAttobecquerels> for UnitAttobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitAttobecquerels) {}
}
impl Sub<UnitAttobecquerels> for UnitAttobecquerels {
    type Output = UnitAttobecquerels;
    #[inline]
    fn sub(self, _: UnitAttobecquerels) -> Self::Output {
        UnitAttobecquerels
    }
}
impl SubAssign<UnitAttobecquerels> for UnitAttobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttobecquerels) {}
}
pub struct UnitAttobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitAttobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitAttobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
impl Mul<UnitAttobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitAttobecquerels>;
    fn mul(self, _: UnitAttobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitAttobecquerels)
    }
}
pub struct UnitZeptobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptobecquerels {
    #[inline]
    fn clone(&self) -> UnitZeptobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptobecquerels {
    #[inline]
    fn eq(&self, other: &UnitZeptobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptobecquerels {
    fn default() -> Self {
        UnitZeptobecquerels
    }
}
impl Add<UnitZeptobecquerels> for UnitZeptobecquerels {
    type Output = UnitZeptobecquerels;
    #[inline]
    fn add(self, _: UnitZeptobecquerels) -> Self::Output {
        UnitZeptobecquerels
    }
}
impl AddAssign<UnitZeptobecquerels> for UnitZeptobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptobecquerels) {}
}
impl Sub<UnitZeptobecquerels> for UnitZeptobecquerels {
    type Output = UnitZeptobecquerels;
    #[inline]
    fn sub(self, _: UnitZeptobecquerels) -> Self::Output {
        UnitZeptobecquerels
    }
}
impl SubAssign<UnitZeptobecquerels> for UnitZeptobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptobecquerels) {}
}
pub struct UnitZeptobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitZeptobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
impl Mul<UnitZeptobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitZeptobecquerels>;
    fn mul(self, _: UnitZeptobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitZeptobecquerels)
    }
}
pub struct UnitYoctobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctobecquerels {
    #[inline]
    fn clone(&self) -> UnitYoctobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctobecquerels {
    #[inline]
    fn eq(&self, other: &UnitYoctobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctobecquerels {
    fn default() -> Self {
        UnitYoctobecquerels
    }
}
impl Add<UnitYoctobecquerels> for UnitYoctobecquerels {
    type Output = UnitYoctobecquerels;
    #[inline]
    fn add(self, _: UnitYoctobecquerels) -> Self::Output {
        UnitYoctobecquerels
    }
}
impl AddAssign<UnitYoctobecquerels> for UnitYoctobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctobecquerels) {}
}
impl Sub<UnitYoctobecquerels> for UnitYoctobecquerels {
    type Output = UnitYoctobecquerels;
    #[inline]
    fn sub(self, _: UnitYoctobecquerels) -> Self::Output {
        UnitYoctobecquerels
    }
}
impl SubAssign<UnitYoctobecquerels> for UnitYoctobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctobecquerels) {}
}
pub struct UnitYoctobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitYoctobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
impl Mul<UnitYoctobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitYoctobecquerels>;
    fn mul(self, _: UnitYoctobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitYoctobecquerels)
    }
}
pub struct UnitRontobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontobecquerels {
    #[inline]
    fn clone(&self) -> UnitRontobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontobecquerels {
    #[inline]
    fn eq(&self, other: &UnitRontobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontobecquerels {
    fn default() -> Self {
        UnitRontobecquerels
    }
}
impl Add<UnitRontobecquerels> for UnitRontobecquerels {
    type Output = UnitRontobecquerels;
    #[inline]
    fn add(self, _: UnitRontobecquerels) -> Self::Output {
        UnitRontobecquerels
    }
}
impl AddAssign<UnitRontobecquerels> for UnitRontobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitRontobecquerels) {}
}
impl Sub<UnitRontobecquerels> for UnitRontobecquerels {
    type Output = UnitRontobecquerels;
    #[inline]
    fn sub(self, _: UnitRontobecquerels) -> Self::Output {
        UnitRontobecquerels
    }
}
impl SubAssign<UnitRontobecquerels> for UnitRontobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontobecquerels) {}
}
pub struct UnitRontobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitRontobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitRontobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
impl Mul<UnitRontobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitRontobecquerels>;
    fn mul(self, _: UnitRontobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitRontobecquerels)
    }
}
pub struct UnitQuectobecquerels;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectobecquerels {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectobecquerels")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectobecquerels {
    #[inline]
    fn clone(&self) -> UnitQuectobecquerels {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectobecquerels {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectobecquerels {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectobecquerels {
    #[inline]
    fn eq(&self, other: &UnitQuectobecquerels) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectobecquerels {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectobecquerels {
    fn default() -> Self {
        UnitQuectobecquerels
    }
}
impl Add<UnitQuectobecquerels> for UnitQuectobecquerels {
    type Output = UnitQuectobecquerels;
    #[inline]
    fn add(self, _: UnitQuectobecquerels) -> Self::Output {
        UnitQuectobecquerels
    }
}
impl AddAssign<UnitQuectobecquerels> for UnitQuectobecquerels {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectobecquerels) {}
}
impl Sub<UnitQuectobecquerels> for UnitQuectobecquerels {
    type Output = UnitQuectobecquerels;
    #[inline]
    fn sub(self, _: UnitQuectobecquerels) -> Self::Output {
        UnitQuectobecquerels
    }
}
impl SubAssign<UnitQuectobecquerels> for UnitQuectobecquerels {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectobecquerels) {}
}
pub struct UnitQuectobecquerelsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectobecquerelsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectobecquerelsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectobecquerelsMul {
    #[inline]
    fn clone(&self) -> UnitQuectobecquerelsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectobecquerelsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectobecquerelsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectobecquerelsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectobecquerelsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectobecquerelsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectobecquerelsMul> for i8 {
    type Output = Quantity<i8, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for i16 {
    type Output = Quantity<i16, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for i32 {
    type Output = Quantity<i32, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for i64 {
    type Output = Quantity<i64, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for i128 {
    type Output = Quantity<i128, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for isize {
    type Output = Quantity<isize, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for u8 {
    type Output = Quantity<u8, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for u16 {
    type Output = Quantity<u16, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for u32 {
    type Output = Quantity<u32, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for u64 {
    type Output = Quantity<u64, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for u128 {
    type Output = Quantity<u128, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for usize {
    type Output = Quantity<usize, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for f32 {
    type Output = Quantity<f32, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
impl Mul<UnitQuectobecquerelsMul> for f64 {
    type Output = Quantity<f64, UnitQuectobecquerels>;
    fn mul(self, _: UnitQuectobecquerelsMul) -> Self::Output {
        Quantity::new(self, UnitQuectobecquerels)
    }
}
pub type Becquerels<T> = Quantity<T, UnitBecquerels>;
#[allow(non_upper_case_globals)]
pub static Becquerels: UnitBecquerelsMul = UnitBecquerelsMul;
pub type Quettabecquerels<T> = Quantity<T, UnitQuettabecquerels>;
#[allow(non_upper_case_globals)]
pub static Quettabecquerels: UnitQuettabecquerelsMul = UnitQuettabecquerelsMul;
pub type Ronnabecquerels<T> = Quantity<T, UnitRonnabecquerels>;
#[allow(non_upper_case_globals)]
pub static Ronnabecquerels: UnitRonnabecquerelsMul = UnitRonnabecquerelsMul;
pub type Yottabecquerels<T> = Quantity<T, UnitYottabecquerels>;
#[allow(non_upper_case_globals)]
pub static Yottabecquerels: UnitYottabecquerelsMul = UnitYottabecquerelsMul;
pub type Zettabecquerels<T> = Quantity<T, UnitZettabecquerels>;
#[allow(non_upper_case_globals)]
pub static Zettabecquerels: UnitZettabecquerelsMul = UnitZettabecquerelsMul;
pub type Exabecquerels<T> = Quantity<T, UnitExabecquerels>;
#[allow(non_upper_case_globals)]
pub static Exabecquerels: UnitExabecquerelsMul = UnitExabecquerelsMul;
pub type Petabecquerels<T> = Quantity<T, UnitPetabecquerels>;
#[allow(non_upper_case_globals)]
pub static Petabecquerels: UnitPetabecquerelsMul = UnitPetabecquerelsMul;
pub type Terabecquerels<T> = Quantity<T, UnitTerabecquerels>;
#[allow(non_upper_case_globals)]
pub static Terabecquerels: UnitTerabecquerelsMul = UnitTerabecquerelsMul;
pub type Gigabecquerels<T> = Quantity<T, UnitGigabecquerels>;
#[allow(non_upper_case_globals)]
pub static Gigabecquerels: UnitGigabecquerelsMul = UnitGigabecquerelsMul;
pub type Megabecquerels<T> = Quantity<T, UnitMegabecquerels>;
#[allow(non_upper_case_globals)]
pub static Megabecquerels: UnitMegabecquerelsMul = UnitMegabecquerelsMul;
pub type Kilobecquerels<T> = Quantity<T, UnitKilobecquerels>;
#[allow(non_upper_case_globals)]
pub static Kilobecquerels: UnitKilobecquerelsMul = UnitKilobecquerelsMul;
pub type Hectobecquerels<T> = Quantity<T, UnitHectobecquerels>;
#[allow(non_upper_case_globals)]
pub static Hectobecquerels: UnitHectobecquerelsMul = UnitHectobecquerelsMul;
pub type Decabecquerels<T> = Quantity<T, UnitDecabecquerels>;
#[allow(non_upper_case_globals)]
pub static Decabecquerels: UnitDecabecquerelsMul = UnitDecabecquerelsMul;
pub type Decibecquerels<T> = Quantity<T, UnitDecibecquerels>;
#[allow(non_upper_case_globals)]
pub static Decibecquerels: UnitDecibecquerelsMul = UnitDecibecquerelsMul;
pub type Centibecquerels<T> = Quantity<T, UnitCentibecquerels>;
#[allow(non_upper_case_globals)]
pub static Centibecquerels: UnitCentibecquerelsMul = UnitCentibecquerelsMul;
pub type Millibecquerels<T> = Quantity<T, UnitMillibecquerels>;
#[allow(non_upper_case_globals)]
pub static Millibecquerels: UnitMillibecquerelsMul = UnitMillibecquerelsMul;
pub type Microbecquerels<T> = Quantity<T, UnitMicrobecquerels>;
#[allow(non_upper_case_globals)]
pub static Microbecquerels: UnitMicrobecquerelsMul = UnitMicrobecquerelsMul;
pub type Nanobecquerels<T> = Quantity<T, UnitNanobecquerels>;
#[allow(non_upper_case_globals)]
pub static Nanobecquerels: UnitNanobecquerelsMul = UnitNanobecquerelsMul;
pub type Picobecquerels<T> = Quantity<T, UnitPicobecquerels>;
#[allow(non_upper_case_globals)]
pub static Picobecquerels: UnitPicobecquerelsMul = UnitPicobecquerelsMul;
pub type Femtobecquerels<T> = Quantity<T, UnitFemtobecquerels>;
#[allow(non_upper_case_globals)]
pub static Femtobecquerels: UnitFemtobecquerelsMul = UnitFemtobecquerelsMul;
pub type Attobecquerels<T> = Quantity<T, UnitAttobecquerels>;
#[allow(non_upper_case_globals)]
pub static Attobecquerels: UnitAttobecquerelsMul = UnitAttobecquerelsMul;
pub type Zeptobecquerels<T> = Quantity<T, UnitZeptobecquerels>;
#[allow(non_upper_case_globals)]
pub static Zeptobecquerels: UnitZeptobecquerelsMul = UnitZeptobecquerelsMul;
pub type Yoctobecquerels<T> = Quantity<T, UnitYoctobecquerels>;
#[allow(non_upper_case_globals)]
pub static Yoctobecquerels: UnitYoctobecquerelsMul = UnitYoctobecquerelsMul;
pub type Rontobecquerels<T> = Quantity<T, UnitRontobecquerels>;
#[allow(non_upper_case_globals)]
pub static Rontobecquerels: UnitRontobecquerelsMul = UnitRontobecquerelsMul;
pub type Quectobecquerels<T> = Quantity<T, UnitQuectobecquerels>;
#[allow(non_upper_case_globals)]
pub static Quectobecquerels: UnitQuectobecquerelsMul = UnitQuectobecquerelsMul;
pub struct UnitGrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGrays {
    #[inline]
    fn clone(&self) -> UnitGrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGrays {
    #[inline]
    fn eq(&self, other: &UnitGrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGrays {
    fn default() -> Self {
        UnitGrays
    }
}
impl Add<UnitGrays> for UnitGrays {
    type Output = UnitGrays;
    #[inline]
    fn add(self, _: UnitGrays) -> Self::Output {
        UnitGrays
    }
}
impl AddAssign<UnitGrays> for UnitGrays {
    #[inline]
    fn add_assign(&mut self, _: UnitGrays) {}
}
impl Sub<UnitGrays> for UnitGrays {
    type Output = UnitGrays;
    #[inline]
    fn sub(self, _: UnitGrays) -> Self::Output {
        UnitGrays
    }
}
impl SubAssign<UnitGrays> for UnitGrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitGrays) {}
}
pub struct UnitGraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGraysMul {
    #[inline]
    fn clone(&self) -> UnitGraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGraysMul {
    #[inline]
    fn eq(&self, other: &UnitGraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGraysMul> for i8 {
    type Output = Quantity<i8, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for i16 {
    type Output = Quantity<i16, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for i32 {
    type Output = Quantity<i32, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for i64 {
    type Output = Quantity<i64, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for i128 {
    type Output = Quantity<i128, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for isize {
    type Output = Quantity<isize, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for u8 {
    type Output = Quantity<u8, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for u16 {
    type Output = Quantity<u16, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for u32 {
    type Output = Quantity<u32, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for u64 {
    type Output = Quantity<u64, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for u128 {
    type Output = Quantity<u128, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for usize {
    type Output = Quantity<usize, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for f32 {
    type Output = Quantity<f32, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
impl Mul<UnitGraysMul> for f64 {
    type Output = Quantity<f64, UnitGrays>;
    fn mul(self, _: UnitGraysMul) -> Self::Output {
        Quantity::new(self, UnitGrays)
    }
}
pub struct UnitQuettagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagrays {
    #[inline]
    fn clone(&self) -> UnitQuettagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagrays {
    #[inline]
    fn eq(&self, other: &UnitQuettagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettagrays {
    fn default() -> Self {
        UnitQuettagrays
    }
}
impl Add<UnitQuettagrays> for UnitQuettagrays {
    type Output = UnitQuettagrays;
    #[inline]
    fn add(self, _: UnitQuettagrays) -> Self::Output {
        UnitQuettagrays
    }
}
impl AddAssign<UnitQuettagrays> for UnitQuettagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettagrays) {}
}
impl Sub<UnitQuettagrays> for UnitQuettagrays {
    type Output = UnitQuettagrays;
    #[inline]
    fn sub(self, _: UnitQuettagrays) -> Self::Output {
        UnitQuettagrays
    }
}
impl SubAssign<UnitQuettagrays> for UnitQuettagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettagrays) {}
}
pub struct UnitQuettagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagraysMul {
    #[inline]
    fn clone(&self) -> UnitQuettagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagraysMul {
    #[inline]
    fn eq(&self, other: &UnitQuettagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettagraysMul> for i8 {
    type Output = Quantity<i8, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for i16 {
    type Output = Quantity<i16, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for i32 {
    type Output = Quantity<i32, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for i64 {
    type Output = Quantity<i64, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for i128 {
    type Output = Quantity<i128, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for isize {
    type Output = Quantity<isize, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for u8 {
    type Output = Quantity<u8, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for u16 {
    type Output = Quantity<u16, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for u32 {
    type Output = Quantity<u32, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for u64 {
    type Output = Quantity<u64, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for u128 {
    type Output = Quantity<u128, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for usize {
    type Output = Quantity<usize, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for f32 {
    type Output = Quantity<f32, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
impl Mul<UnitQuettagraysMul> for f64 {
    type Output = Quantity<f64, UnitQuettagrays>;
    fn mul(self, _: UnitQuettagraysMul) -> Self::Output {
        Quantity::new(self, UnitQuettagrays)
    }
}
pub struct UnitRonnagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagrays {
    #[inline]
    fn clone(&self) -> UnitRonnagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagrays {
    #[inline]
    fn eq(&self, other: &UnitRonnagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnagrays {
    fn default() -> Self {
        UnitRonnagrays
    }
}
impl Add<UnitRonnagrays> for UnitRonnagrays {
    type Output = UnitRonnagrays;
    #[inline]
    fn add(self, _: UnitRonnagrays) -> Self::Output {
        UnitRonnagrays
    }
}
impl AddAssign<UnitRonnagrays> for UnitRonnagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnagrays) {}
}
impl Sub<UnitRonnagrays> for UnitRonnagrays {
    type Output = UnitRonnagrays;
    #[inline]
    fn sub(self, _: UnitRonnagrays) -> Self::Output {
        UnitRonnagrays
    }
}
impl SubAssign<UnitRonnagrays> for UnitRonnagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnagrays) {}
}
pub struct UnitRonnagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagraysMul {
    #[inline]
    fn clone(&self) -> UnitRonnagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagraysMul {
    #[inline]
    fn eq(&self, other: &UnitRonnagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnagraysMul> for i8 {
    type Output = Quantity<i8, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for i16 {
    type Output = Quantity<i16, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for i32 {
    type Output = Quantity<i32, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for i64 {
    type Output = Quantity<i64, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for i128 {
    type Output = Quantity<i128, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for isize {
    type Output = Quantity<isize, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for u8 {
    type Output = Quantity<u8, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for u16 {
    type Output = Quantity<u16, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for u32 {
    type Output = Quantity<u32, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for u64 {
    type Output = Quantity<u64, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for u128 {
    type Output = Quantity<u128, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for usize {
    type Output = Quantity<usize, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for f32 {
    type Output = Quantity<f32, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
impl Mul<UnitRonnagraysMul> for f64 {
    type Output = Quantity<f64, UnitRonnagrays>;
    fn mul(self, _: UnitRonnagraysMul) -> Self::Output {
        Quantity::new(self, UnitRonnagrays)
    }
}
pub struct UnitYottagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagrays {
    #[inline]
    fn clone(&self) -> UnitYottagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagrays {
    #[inline]
    fn eq(&self, other: &UnitYottagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottagrays {
    fn default() -> Self {
        UnitYottagrays
    }
}
impl Add<UnitYottagrays> for UnitYottagrays {
    type Output = UnitYottagrays;
    #[inline]
    fn add(self, _: UnitYottagrays) -> Self::Output {
        UnitYottagrays
    }
}
impl AddAssign<UnitYottagrays> for UnitYottagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitYottagrays) {}
}
impl Sub<UnitYottagrays> for UnitYottagrays {
    type Output = UnitYottagrays;
    #[inline]
    fn sub(self, _: UnitYottagrays) -> Self::Output {
        UnitYottagrays
    }
}
impl SubAssign<UnitYottagrays> for UnitYottagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottagrays) {}
}
pub struct UnitYottagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagraysMul {
    #[inline]
    fn clone(&self) -> UnitYottagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagraysMul {
    #[inline]
    fn eq(&self, other: &UnitYottagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottagraysMul> for i8 {
    type Output = Quantity<i8, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for i16 {
    type Output = Quantity<i16, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for i32 {
    type Output = Quantity<i32, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for i64 {
    type Output = Quantity<i64, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for i128 {
    type Output = Quantity<i128, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for isize {
    type Output = Quantity<isize, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for u8 {
    type Output = Quantity<u8, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for u16 {
    type Output = Quantity<u16, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for u32 {
    type Output = Quantity<u32, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for u64 {
    type Output = Quantity<u64, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for u128 {
    type Output = Quantity<u128, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for usize {
    type Output = Quantity<usize, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for f32 {
    type Output = Quantity<f32, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
impl Mul<UnitYottagraysMul> for f64 {
    type Output = Quantity<f64, UnitYottagrays>;
    fn mul(self, _: UnitYottagraysMul) -> Self::Output {
        Quantity::new(self, UnitYottagrays)
    }
}
pub struct UnitZettagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagrays {
    #[inline]
    fn clone(&self) -> UnitZettagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagrays {
    #[inline]
    fn eq(&self, other: &UnitZettagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettagrays {
    fn default() -> Self {
        UnitZettagrays
    }
}
impl Add<UnitZettagrays> for UnitZettagrays {
    type Output = UnitZettagrays;
    #[inline]
    fn add(self, _: UnitZettagrays) -> Self::Output {
        UnitZettagrays
    }
}
impl AddAssign<UnitZettagrays> for UnitZettagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitZettagrays) {}
}
impl Sub<UnitZettagrays> for UnitZettagrays {
    type Output = UnitZettagrays;
    #[inline]
    fn sub(self, _: UnitZettagrays) -> Self::Output {
        UnitZettagrays
    }
}
impl SubAssign<UnitZettagrays> for UnitZettagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettagrays) {}
}
pub struct UnitZettagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagraysMul {
    #[inline]
    fn clone(&self) -> UnitZettagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagraysMul {
    #[inline]
    fn eq(&self, other: &UnitZettagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettagraysMul> for i8 {
    type Output = Quantity<i8, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for i16 {
    type Output = Quantity<i16, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for i32 {
    type Output = Quantity<i32, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for i64 {
    type Output = Quantity<i64, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for i128 {
    type Output = Quantity<i128, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for isize {
    type Output = Quantity<isize, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for u8 {
    type Output = Quantity<u8, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for u16 {
    type Output = Quantity<u16, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for u32 {
    type Output = Quantity<u32, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for u64 {
    type Output = Quantity<u64, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for u128 {
    type Output = Quantity<u128, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for usize {
    type Output = Quantity<usize, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for f32 {
    type Output = Quantity<f32, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
impl Mul<UnitZettagraysMul> for f64 {
    type Output = Quantity<f64, UnitZettagrays>;
    fn mul(self, _: UnitZettagraysMul) -> Self::Output {
        Quantity::new(self, UnitZettagrays)
    }
}
pub struct UnitExagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagrays {
    #[inline]
    fn clone(&self) -> UnitExagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagrays {
    #[inline]
    fn eq(&self, other: &UnitExagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExagrays {
    fn default() -> Self {
        UnitExagrays
    }
}
impl Add<UnitExagrays> for UnitExagrays {
    type Output = UnitExagrays;
    #[inline]
    fn add(self, _: UnitExagrays) -> Self::Output {
        UnitExagrays
    }
}
impl AddAssign<UnitExagrays> for UnitExagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitExagrays) {}
}
impl Sub<UnitExagrays> for UnitExagrays {
    type Output = UnitExagrays;
    #[inline]
    fn sub(self, _: UnitExagrays) -> Self::Output {
        UnitExagrays
    }
}
impl SubAssign<UnitExagrays> for UnitExagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitExagrays) {}
}
pub struct UnitExagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagraysMul {
    #[inline]
    fn clone(&self) -> UnitExagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagraysMul {
    #[inline]
    fn eq(&self, other: &UnitExagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExagraysMul> for i8 {
    type Output = Quantity<i8, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for i16 {
    type Output = Quantity<i16, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for i32 {
    type Output = Quantity<i32, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for i64 {
    type Output = Quantity<i64, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for i128 {
    type Output = Quantity<i128, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for isize {
    type Output = Quantity<isize, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for u8 {
    type Output = Quantity<u8, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for u16 {
    type Output = Quantity<u16, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for u32 {
    type Output = Quantity<u32, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for u64 {
    type Output = Quantity<u64, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for u128 {
    type Output = Quantity<u128, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for usize {
    type Output = Quantity<usize, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for f32 {
    type Output = Quantity<f32, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
impl Mul<UnitExagraysMul> for f64 {
    type Output = Quantity<f64, UnitExagrays>;
    fn mul(self, _: UnitExagraysMul) -> Self::Output {
        Quantity::new(self, UnitExagrays)
    }
}
pub struct UnitPetagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagrays {
    #[inline]
    fn clone(&self) -> UnitPetagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagrays {
    #[inline]
    fn eq(&self, other: &UnitPetagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetagrays {
    fn default() -> Self {
        UnitPetagrays
    }
}
impl Add<UnitPetagrays> for UnitPetagrays {
    type Output = UnitPetagrays;
    #[inline]
    fn add(self, _: UnitPetagrays) -> Self::Output {
        UnitPetagrays
    }
}
impl AddAssign<UnitPetagrays> for UnitPetagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitPetagrays) {}
}
impl Sub<UnitPetagrays> for UnitPetagrays {
    type Output = UnitPetagrays;
    #[inline]
    fn sub(self, _: UnitPetagrays) -> Self::Output {
        UnitPetagrays
    }
}
impl SubAssign<UnitPetagrays> for UnitPetagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetagrays) {}
}
pub struct UnitPetagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagraysMul {
    #[inline]
    fn clone(&self) -> UnitPetagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagraysMul {
    #[inline]
    fn eq(&self, other: &UnitPetagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetagraysMul> for i8 {
    type Output = Quantity<i8, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for i16 {
    type Output = Quantity<i16, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for i32 {
    type Output = Quantity<i32, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for i64 {
    type Output = Quantity<i64, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for i128 {
    type Output = Quantity<i128, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for isize {
    type Output = Quantity<isize, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for u8 {
    type Output = Quantity<u8, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for u16 {
    type Output = Quantity<u16, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for u32 {
    type Output = Quantity<u32, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for u64 {
    type Output = Quantity<u64, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for u128 {
    type Output = Quantity<u128, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for usize {
    type Output = Quantity<usize, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for f32 {
    type Output = Quantity<f32, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
impl Mul<UnitPetagraysMul> for f64 {
    type Output = Quantity<f64, UnitPetagrays>;
    fn mul(self, _: UnitPetagraysMul) -> Self::Output {
        Quantity::new(self, UnitPetagrays)
    }
}
pub struct UnitTeragrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragrays {
    #[inline]
    fn clone(&self) -> UnitTeragrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragrays {
    #[inline]
    fn eq(&self, other: &UnitTeragrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeragrays {
    fn default() -> Self {
        UnitTeragrays
    }
}
impl Add<UnitTeragrays> for UnitTeragrays {
    type Output = UnitTeragrays;
    #[inline]
    fn add(self, _: UnitTeragrays) -> Self::Output {
        UnitTeragrays
    }
}
impl AddAssign<UnitTeragrays> for UnitTeragrays {
    #[inline]
    fn add_assign(&mut self, _: UnitTeragrays) {}
}
impl Sub<UnitTeragrays> for UnitTeragrays {
    type Output = UnitTeragrays;
    #[inline]
    fn sub(self, _: UnitTeragrays) -> Self::Output {
        UnitTeragrays
    }
}
impl SubAssign<UnitTeragrays> for UnitTeragrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeragrays) {}
}
pub struct UnitTeragraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragraysMul {
    #[inline]
    fn clone(&self) -> UnitTeragraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragraysMul {
    #[inline]
    fn eq(&self, other: &UnitTeragraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeragraysMul> for i8 {
    type Output = Quantity<i8, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for i16 {
    type Output = Quantity<i16, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for i32 {
    type Output = Quantity<i32, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for i64 {
    type Output = Quantity<i64, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for i128 {
    type Output = Quantity<i128, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for isize {
    type Output = Quantity<isize, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for u8 {
    type Output = Quantity<u8, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for u16 {
    type Output = Quantity<u16, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for u32 {
    type Output = Quantity<u32, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for u64 {
    type Output = Quantity<u64, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for u128 {
    type Output = Quantity<u128, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for usize {
    type Output = Quantity<usize, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for f32 {
    type Output = Quantity<f32, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
impl Mul<UnitTeragraysMul> for f64 {
    type Output = Quantity<f64, UnitTeragrays>;
    fn mul(self, _: UnitTeragraysMul) -> Self::Output {
        Quantity::new(self, UnitTeragrays)
    }
}
pub struct UnitGigagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagrays {
    #[inline]
    fn clone(&self) -> UnitGigagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagrays {
    #[inline]
    fn eq(&self, other: &UnitGigagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigagrays {
    fn default() -> Self {
        UnitGigagrays
    }
}
impl Add<UnitGigagrays> for UnitGigagrays {
    type Output = UnitGigagrays;
    #[inline]
    fn add(self, _: UnitGigagrays) -> Self::Output {
        UnitGigagrays
    }
}
impl AddAssign<UnitGigagrays> for UnitGigagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitGigagrays) {}
}
impl Sub<UnitGigagrays> for UnitGigagrays {
    type Output = UnitGigagrays;
    #[inline]
    fn sub(self, _: UnitGigagrays) -> Self::Output {
        UnitGigagrays
    }
}
impl SubAssign<UnitGigagrays> for UnitGigagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigagrays) {}
}
pub struct UnitGigagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagraysMul {
    #[inline]
    fn clone(&self) -> UnitGigagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagraysMul {
    #[inline]
    fn eq(&self, other: &UnitGigagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigagraysMul> for i8 {
    type Output = Quantity<i8, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for i16 {
    type Output = Quantity<i16, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for i32 {
    type Output = Quantity<i32, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for i64 {
    type Output = Quantity<i64, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for i128 {
    type Output = Quantity<i128, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for isize {
    type Output = Quantity<isize, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for u8 {
    type Output = Quantity<u8, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for u16 {
    type Output = Quantity<u16, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for u32 {
    type Output = Quantity<u32, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for u64 {
    type Output = Quantity<u64, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for u128 {
    type Output = Quantity<u128, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for usize {
    type Output = Quantity<usize, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for f32 {
    type Output = Quantity<f32, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
impl Mul<UnitGigagraysMul> for f64 {
    type Output = Quantity<f64, UnitGigagrays>;
    fn mul(self, _: UnitGigagraysMul) -> Self::Output {
        Quantity::new(self, UnitGigagrays)
    }
}
pub struct UnitMegagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagrays {
    #[inline]
    fn clone(&self) -> UnitMegagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagrays {
    #[inline]
    fn eq(&self, other: &UnitMegagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegagrays {
    fn default() -> Self {
        UnitMegagrays
    }
}
impl Add<UnitMegagrays> for UnitMegagrays {
    type Output = UnitMegagrays;
    #[inline]
    fn add(self, _: UnitMegagrays) -> Self::Output {
        UnitMegagrays
    }
}
impl AddAssign<UnitMegagrays> for UnitMegagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitMegagrays) {}
}
impl Sub<UnitMegagrays> for UnitMegagrays {
    type Output = UnitMegagrays;
    #[inline]
    fn sub(self, _: UnitMegagrays) -> Self::Output {
        UnitMegagrays
    }
}
impl SubAssign<UnitMegagrays> for UnitMegagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegagrays) {}
}
pub struct UnitMegagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagraysMul {
    #[inline]
    fn clone(&self) -> UnitMegagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagraysMul {
    #[inline]
    fn eq(&self, other: &UnitMegagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegagraysMul> for i8 {
    type Output = Quantity<i8, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for i16 {
    type Output = Quantity<i16, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for i32 {
    type Output = Quantity<i32, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for i64 {
    type Output = Quantity<i64, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for i128 {
    type Output = Quantity<i128, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for isize {
    type Output = Quantity<isize, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for u8 {
    type Output = Quantity<u8, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for u16 {
    type Output = Quantity<u16, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for u32 {
    type Output = Quantity<u32, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for u64 {
    type Output = Quantity<u64, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for u128 {
    type Output = Quantity<u128, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for usize {
    type Output = Quantity<usize, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for f32 {
    type Output = Quantity<f32, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
impl Mul<UnitMegagraysMul> for f64 {
    type Output = Quantity<f64, UnitMegagrays>;
    fn mul(self, _: UnitMegagraysMul) -> Self::Output {
        Quantity::new(self, UnitMegagrays)
    }
}
pub struct UnitKilograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilograys {
    #[inline]
    fn clone(&self) -> UnitKilograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilograys {
    #[inline]
    fn eq(&self, other: &UnitKilograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilograys {
    fn default() -> Self {
        UnitKilograys
    }
}
impl Add<UnitKilograys> for UnitKilograys {
    type Output = UnitKilograys;
    #[inline]
    fn add(self, _: UnitKilograys) -> Self::Output {
        UnitKilograys
    }
}
impl AddAssign<UnitKilograys> for UnitKilograys {
    #[inline]
    fn add_assign(&mut self, _: UnitKilograys) {}
}
impl Sub<UnitKilograys> for UnitKilograys {
    type Output = UnitKilograys;
    #[inline]
    fn sub(self, _: UnitKilograys) -> Self::Output {
        UnitKilograys
    }
}
impl SubAssign<UnitKilograys> for UnitKilograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilograys) {}
}
pub struct UnitKilograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilograysMul {
    #[inline]
    fn clone(&self) -> UnitKilograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilograysMul {
    #[inline]
    fn eq(&self, other: &UnitKilograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilograysMul> for i8 {
    type Output = Quantity<i8, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for i16 {
    type Output = Quantity<i16, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for i32 {
    type Output = Quantity<i32, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for i64 {
    type Output = Quantity<i64, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for i128 {
    type Output = Quantity<i128, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for isize {
    type Output = Quantity<isize, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for u8 {
    type Output = Quantity<u8, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for u16 {
    type Output = Quantity<u16, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for u32 {
    type Output = Quantity<u32, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for u64 {
    type Output = Quantity<u64, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for u128 {
    type Output = Quantity<u128, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for usize {
    type Output = Quantity<usize, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for f32 {
    type Output = Quantity<f32, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
impl Mul<UnitKilograysMul> for f64 {
    type Output = Quantity<f64, UnitKilograys>;
    fn mul(self, _: UnitKilograysMul) -> Self::Output {
        Quantity::new(self, UnitKilograys)
    }
}
pub struct UnitHectograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectograys {
    #[inline]
    fn clone(&self) -> UnitHectograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectograys {
    #[inline]
    fn eq(&self, other: &UnitHectograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectograys {
    fn default() -> Self {
        UnitHectograys
    }
}
impl Add<UnitHectograys> for UnitHectograys {
    type Output = UnitHectograys;
    #[inline]
    fn add(self, _: UnitHectograys) -> Self::Output {
        UnitHectograys
    }
}
impl AddAssign<UnitHectograys> for UnitHectograys {
    #[inline]
    fn add_assign(&mut self, _: UnitHectograys) {}
}
impl Sub<UnitHectograys> for UnitHectograys {
    type Output = UnitHectograys;
    #[inline]
    fn sub(self, _: UnitHectograys) -> Self::Output {
        UnitHectograys
    }
}
impl SubAssign<UnitHectograys> for UnitHectograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectograys) {}
}
pub struct UnitHectograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectograysMul {
    #[inline]
    fn clone(&self) -> UnitHectograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectograysMul {
    #[inline]
    fn eq(&self, other: &UnitHectograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectograysMul> for i8 {
    type Output = Quantity<i8, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for i16 {
    type Output = Quantity<i16, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for i32 {
    type Output = Quantity<i32, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for i64 {
    type Output = Quantity<i64, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for i128 {
    type Output = Quantity<i128, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for isize {
    type Output = Quantity<isize, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for u8 {
    type Output = Quantity<u8, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for u16 {
    type Output = Quantity<u16, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for u32 {
    type Output = Quantity<u32, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for u64 {
    type Output = Quantity<u64, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for u128 {
    type Output = Quantity<u128, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for usize {
    type Output = Quantity<usize, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for f32 {
    type Output = Quantity<f32, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
impl Mul<UnitHectograysMul> for f64 {
    type Output = Quantity<f64, UnitHectograys>;
    fn mul(self, _: UnitHectograysMul) -> Self::Output {
        Quantity::new(self, UnitHectograys)
    }
}
pub struct UnitDecagrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagrays {
    #[inline]
    fn clone(&self) -> UnitDecagrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagrays {
    #[inline]
    fn eq(&self, other: &UnitDecagrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecagrays {
    fn default() -> Self {
        UnitDecagrays
    }
}
impl Add<UnitDecagrays> for UnitDecagrays {
    type Output = UnitDecagrays;
    #[inline]
    fn add(self, _: UnitDecagrays) -> Self::Output {
        UnitDecagrays
    }
}
impl AddAssign<UnitDecagrays> for UnitDecagrays {
    #[inline]
    fn add_assign(&mut self, _: UnitDecagrays) {}
}
impl Sub<UnitDecagrays> for UnitDecagrays {
    type Output = UnitDecagrays;
    #[inline]
    fn sub(self, _: UnitDecagrays) -> Self::Output {
        UnitDecagrays
    }
}
impl SubAssign<UnitDecagrays> for UnitDecagrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecagrays) {}
}
pub struct UnitDecagraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagraysMul {
    #[inline]
    fn clone(&self) -> UnitDecagraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagraysMul {
    #[inline]
    fn eq(&self, other: &UnitDecagraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecagraysMul> for i8 {
    type Output = Quantity<i8, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for i16 {
    type Output = Quantity<i16, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for i32 {
    type Output = Quantity<i32, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for i64 {
    type Output = Quantity<i64, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for i128 {
    type Output = Quantity<i128, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for isize {
    type Output = Quantity<isize, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for u8 {
    type Output = Quantity<u8, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for u16 {
    type Output = Quantity<u16, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for u32 {
    type Output = Quantity<u32, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for u64 {
    type Output = Quantity<u64, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for u128 {
    type Output = Quantity<u128, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for usize {
    type Output = Quantity<usize, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for f32 {
    type Output = Quantity<f32, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
impl Mul<UnitDecagraysMul> for f64 {
    type Output = Quantity<f64, UnitDecagrays>;
    fn mul(self, _: UnitDecagraysMul) -> Self::Output {
        Quantity::new(self, UnitDecagrays)
    }
}
pub struct UnitDecigrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigrays {
    #[inline]
    fn clone(&self) -> UnitDecigrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigrays {
    #[inline]
    fn eq(&self, other: &UnitDecigrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecigrays {
    fn default() -> Self {
        UnitDecigrays
    }
}
impl Add<UnitDecigrays> for UnitDecigrays {
    type Output = UnitDecigrays;
    #[inline]
    fn add(self, _: UnitDecigrays) -> Self::Output {
        UnitDecigrays
    }
}
impl AddAssign<UnitDecigrays> for UnitDecigrays {
    #[inline]
    fn add_assign(&mut self, _: UnitDecigrays) {}
}
impl Sub<UnitDecigrays> for UnitDecigrays {
    type Output = UnitDecigrays;
    #[inline]
    fn sub(self, _: UnitDecigrays) -> Self::Output {
        UnitDecigrays
    }
}
impl SubAssign<UnitDecigrays> for UnitDecigrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecigrays) {}
}
pub struct UnitDecigraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigraysMul {
    #[inline]
    fn clone(&self) -> UnitDecigraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigraysMul {
    #[inline]
    fn eq(&self, other: &UnitDecigraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecigraysMul> for i8 {
    type Output = Quantity<i8, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for i16 {
    type Output = Quantity<i16, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for i32 {
    type Output = Quantity<i32, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for i64 {
    type Output = Quantity<i64, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for i128 {
    type Output = Quantity<i128, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for isize {
    type Output = Quantity<isize, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for u8 {
    type Output = Quantity<u8, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for u16 {
    type Output = Quantity<u16, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for u32 {
    type Output = Quantity<u32, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for u64 {
    type Output = Quantity<u64, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for u128 {
    type Output = Quantity<u128, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for usize {
    type Output = Quantity<usize, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for f32 {
    type Output = Quantity<f32, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
impl Mul<UnitDecigraysMul> for f64 {
    type Output = Quantity<f64, UnitDecigrays>;
    fn mul(self, _: UnitDecigraysMul) -> Self::Output {
        Quantity::new(self, UnitDecigrays)
    }
}
pub struct UnitCentigrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigrays {
    #[inline]
    fn clone(&self) -> UnitCentigrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigrays {
    #[inline]
    fn eq(&self, other: &UnitCentigrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentigrays {
    fn default() -> Self {
        UnitCentigrays
    }
}
impl Add<UnitCentigrays> for UnitCentigrays {
    type Output = UnitCentigrays;
    #[inline]
    fn add(self, _: UnitCentigrays) -> Self::Output {
        UnitCentigrays
    }
}
impl AddAssign<UnitCentigrays> for UnitCentigrays {
    #[inline]
    fn add_assign(&mut self, _: UnitCentigrays) {}
}
impl Sub<UnitCentigrays> for UnitCentigrays {
    type Output = UnitCentigrays;
    #[inline]
    fn sub(self, _: UnitCentigrays) -> Self::Output {
        UnitCentigrays
    }
}
impl SubAssign<UnitCentigrays> for UnitCentigrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentigrays) {}
}
pub struct UnitCentigraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigraysMul {
    #[inline]
    fn clone(&self) -> UnitCentigraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigraysMul {
    #[inline]
    fn eq(&self, other: &UnitCentigraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentigraysMul> for i8 {
    type Output = Quantity<i8, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for i16 {
    type Output = Quantity<i16, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for i32 {
    type Output = Quantity<i32, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for i64 {
    type Output = Quantity<i64, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for i128 {
    type Output = Quantity<i128, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for isize {
    type Output = Quantity<isize, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for u8 {
    type Output = Quantity<u8, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for u16 {
    type Output = Quantity<u16, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for u32 {
    type Output = Quantity<u32, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for u64 {
    type Output = Quantity<u64, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for u128 {
    type Output = Quantity<u128, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for usize {
    type Output = Quantity<usize, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for f32 {
    type Output = Quantity<f32, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
impl Mul<UnitCentigraysMul> for f64 {
    type Output = Quantity<f64, UnitCentigrays>;
    fn mul(self, _: UnitCentigraysMul) -> Self::Output {
        Quantity::new(self, UnitCentigrays)
    }
}
pub struct UnitMilligrays;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligrays {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligrays")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligrays {
    #[inline]
    fn clone(&self) -> UnitMilligrays {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligrays {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligrays {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligrays {
    #[inline]
    fn eq(&self, other: &UnitMilligrays) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligrays {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilligrays {
    fn default() -> Self {
        UnitMilligrays
    }
}
impl Add<UnitMilligrays> for UnitMilligrays {
    type Output = UnitMilligrays;
    #[inline]
    fn add(self, _: UnitMilligrays) -> Self::Output {
        UnitMilligrays
    }
}
impl AddAssign<UnitMilligrays> for UnitMilligrays {
    #[inline]
    fn add_assign(&mut self, _: UnitMilligrays) {}
}
impl Sub<UnitMilligrays> for UnitMilligrays {
    type Output = UnitMilligrays;
    #[inline]
    fn sub(self, _: UnitMilligrays) -> Self::Output {
        UnitMilligrays
    }
}
impl SubAssign<UnitMilligrays> for UnitMilligrays {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilligrays) {}
}
pub struct UnitMilligraysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligraysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligraysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligraysMul {
    #[inline]
    fn clone(&self) -> UnitMilligraysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligraysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligraysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligraysMul {
    #[inline]
    fn eq(&self, other: &UnitMilligraysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligraysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilligraysMul> for i8 {
    type Output = Quantity<i8, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for i16 {
    type Output = Quantity<i16, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for i32 {
    type Output = Quantity<i32, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for i64 {
    type Output = Quantity<i64, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for i128 {
    type Output = Quantity<i128, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for isize {
    type Output = Quantity<isize, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for u8 {
    type Output = Quantity<u8, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for u16 {
    type Output = Quantity<u16, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for u32 {
    type Output = Quantity<u32, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for u64 {
    type Output = Quantity<u64, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for u128 {
    type Output = Quantity<u128, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for usize {
    type Output = Quantity<usize, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for f32 {
    type Output = Quantity<f32, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
impl Mul<UnitMilligraysMul> for f64 {
    type Output = Quantity<f64, UnitMilligrays>;
    fn mul(self, _: UnitMilligraysMul) -> Self::Output {
        Quantity::new(self, UnitMilligrays)
    }
}
pub struct UnitMicrograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrograys {
    #[inline]
    fn clone(&self) -> UnitMicrograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrograys {
    #[inline]
    fn eq(&self, other: &UnitMicrograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrograys {
    fn default() -> Self {
        UnitMicrograys
    }
}
impl Add<UnitMicrograys> for UnitMicrograys {
    type Output = UnitMicrograys;
    #[inline]
    fn add(self, _: UnitMicrograys) -> Self::Output {
        UnitMicrograys
    }
}
impl AddAssign<UnitMicrograys> for UnitMicrograys {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrograys) {}
}
impl Sub<UnitMicrograys> for UnitMicrograys {
    type Output = UnitMicrograys;
    #[inline]
    fn sub(self, _: UnitMicrograys) -> Self::Output {
        UnitMicrograys
    }
}
impl SubAssign<UnitMicrograys> for UnitMicrograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrograys) {}
}
pub struct UnitMicrograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrograysMul {
    #[inline]
    fn clone(&self) -> UnitMicrograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrograysMul {
    #[inline]
    fn eq(&self, other: &UnitMicrograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrograysMul> for i8 {
    type Output = Quantity<i8, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for i16 {
    type Output = Quantity<i16, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for i32 {
    type Output = Quantity<i32, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for i64 {
    type Output = Quantity<i64, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for i128 {
    type Output = Quantity<i128, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for isize {
    type Output = Quantity<isize, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for u8 {
    type Output = Quantity<u8, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for u16 {
    type Output = Quantity<u16, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for u32 {
    type Output = Quantity<u32, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for u64 {
    type Output = Quantity<u64, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for u128 {
    type Output = Quantity<u128, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for usize {
    type Output = Quantity<usize, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for f32 {
    type Output = Quantity<f32, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
impl Mul<UnitMicrograysMul> for f64 {
    type Output = Quantity<f64, UnitMicrograys>;
    fn mul(self, _: UnitMicrograysMul) -> Self::Output {
        Quantity::new(self, UnitMicrograys)
    }
}
pub struct UnitNanograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanograys {
    #[inline]
    fn clone(&self) -> UnitNanograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanograys {
    #[inline]
    fn eq(&self, other: &UnitNanograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanograys {
    fn default() -> Self {
        UnitNanograys
    }
}
impl Add<UnitNanograys> for UnitNanograys {
    type Output = UnitNanograys;
    #[inline]
    fn add(self, _: UnitNanograys) -> Self::Output {
        UnitNanograys
    }
}
impl AddAssign<UnitNanograys> for UnitNanograys {
    #[inline]
    fn add_assign(&mut self, _: UnitNanograys) {}
}
impl Sub<UnitNanograys> for UnitNanograys {
    type Output = UnitNanograys;
    #[inline]
    fn sub(self, _: UnitNanograys) -> Self::Output {
        UnitNanograys
    }
}
impl SubAssign<UnitNanograys> for UnitNanograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanograys) {}
}
pub struct UnitNanograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanograysMul {
    #[inline]
    fn clone(&self) -> UnitNanograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanograysMul {
    #[inline]
    fn eq(&self, other: &UnitNanograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanograysMul> for i8 {
    type Output = Quantity<i8, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for i16 {
    type Output = Quantity<i16, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for i32 {
    type Output = Quantity<i32, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for i64 {
    type Output = Quantity<i64, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for i128 {
    type Output = Quantity<i128, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for isize {
    type Output = Quantity<isize, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for u8 {
    type Output = Quantity<u8, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for u16 {
    type Output = Quantity<u16, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for u32 {
    type Output = Quantity<u32, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for u64 {
    type Output = Quantity<u64, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for u128 {
    type Output = Quantity<u128, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for usize {
    type Output = Quantity<usize, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for f32 {
    type Output = Quantity<f32, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
impl Mul<UnitNanograysMul> for f64 {
    type Output = Quantity<f64, UnitNanograys>;
    fn mul(self, _: UnitNanograysMul) -> Self::Output {
        Quantity::new(self, UnitNanograys)
    }
}
pub struct UnitPicograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicograys {
    #[inline]
    fn clone(&self) -> UnitPicograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicograys {
    #[inline]
    fn eq(&self, other: &UnitPicograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicograys {
    fn default() -> Self {
        UnitPicograys
    }
}
impl Add<UnitPicograys> for UnitPicograys {
    type Output = UnitPicograys;
    #[inline]
    fn add(self, _: UnitPicograys) -> Self::Output {
        UnitPicograys
    }
}
impl AddAssign<UnitPicograys> for UnitPicograys {
    #[inline]
    fn add_assign(&mut self, _: UnitPicograys) {}
}
impl Sub<UnitPicograys> for UnitPicograys {
    type Output = UnitPicograys;
    #[inline]
    fn sub(self, _: UnitPicograys) -> Self::Output {
        UnitPicograys
    }
}
impl SubAssign<UnitPicograys> for UnitPicograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicograys) {}
}
pub struct UnitPicograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicograysMul {
    #[inline]
    fn clone(&self) -> UnitPicograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicograysMul {
    #[inline]
    fn eq(&self, other: &UnitPicograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicograysMul> for i8 {
    type Output = Quantity<i8, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for i16 {
    type Output = Quantity<i16, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for i32 {
    type Output = Quantity<i32, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for i64 {
    type Output = Quantity<i64, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for i128 {
    type Output = Quantity<i128, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for isize {
    type Output = Quantity<isize, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for u8 {
    type Output = Quantity<u8, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for u16 {
    type Output = Quantity<u16, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for u32 {
    type Output = Quantity<u32, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for u64 {
    type Output = Quantity<u64, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for u128 {
    type Output = Quantity<u128, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for usize {
    type Output = Quantity<usize, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for f32 {
    type Output = Quantity<f32, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
impl Mul<UnitPicograysMul> for f64 {
    type Output = Quantity<f64, UnitPicograys>;
    fn mul(self, _: UnitPicograysMul) -> Self::Output {
        Quantity::new(self, UnitPicograys)
    }
}
pub struct UnitFemtograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtograys {
    #[inline]
    fn clone(&self) -> UnitFemtograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtograys {
    #[inline]
    fn eq(&self, other: &UnitFemtograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtograys {
    fn default() -> Self {
        UnitFemtograys
    }
}
impl Add<UnitFemtograys> for UnitFemtograys {
    type Output = UnitFemtograys;
    #[inline]
    fn add(self, _: UnitFemtograys) -> Self::Output {
        UnitFemtograys
    }
}
impl AddAssign<UnitFemtograys> for UnitFemtograys {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtograys) {}
}
impl Sub<UnitFemtograys> for UnitFemtograys {
    type Output = UnitFemtograys;
    #[inline]
    fn sub(self, _: UnitFemtograys) -> Self::Output {
        UnitFemtograys
    }
}
impl SubAssign<UnitFemtograys> for UnitFemtograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtograys) {}
}
pub struct UnitFemtograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtograysMul {
    #[inline]
    fn clone(&self) -> UnitFemtograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtograysMul {
    #[inline]
    fn eq(&self, other: &UnitFemtograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtograysMul> for i8 {
    type Output = Quantity<i8, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for i16 {
    type Output = Quantity<i16, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for i32 {
    type Output = Quantity<i32, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for i64 {
    type Output = Quantity<i64, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for i128 {
    type Output = Quantity<i128, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for isize {
    type Output = Quantity<isize, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for u8 {
    type Output = Quantity<u8, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for u16 {
    type Output = Quantity<u16, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for u32 {
    type Output = Quantity<u32, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for u64 {
    type Output = Quantity<u64, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for u128 {
    type Output = Quantity<u128, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for usize {
    type Output = Quantity<usize, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for f32 {
    type Output = Quantity<f32, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
impl Mul<UnitFemtograysMul> for f64 {
    type Output = Quantity<f64, UnitFemtograys>;
    fn mul(self, _: UnitFemtograysMul) -> Self::Output {
        Quantity::new(self, UnitFemtograys)
    }
}
pub struct UnitAttograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttograys {
    #[inline]
    fn clone(&self) -> UnitAttograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttograys {
    #[inline]
    fn eq(&self, other: &UnitAttograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttograys {
    fn default() -> Self {
        UnitAttograys
    }
}
impl Add<UnitAttograys> for UnitAttograys {
    type Output = UnitAttograys;
    #[inline]
    fn add(self, _: UnitAttograys) -> Self::Output {
        UnitAttograys
    }
}
impl AddAssign<UnitAttograys> for UnitAttograys {
    #[inline]
    fn add_assign(&mut self, _: UnitAttograys) {}
}
impl Sub<UnitAttograys> for UnitAttograys {
    type Output = UnitAttograys;
    #[inline]
    fn sub(self, _: UnitAttograys) -> Self::Output {
        UnitAttograys
    }
}
impl SubAssign<UnitAttograys> for UnitAttograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttograys) {}
}
pub struct UnitAttograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttograysMul {
    #[inline]
    fn clone(&self) -> UnitAttograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttograysMul {
    #[inline]
    fn eq(&self, other: &UnitAttograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttograysMul> for i8 {
    type Output = Quantity<i8, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for i16 {
    type Output = Quantity<i16, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for i32 {
    type Output = Quantity<i32, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for i64 {
    type Output = Quantity<i64, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for i128 {
    type Output = Quantity<i128, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for isize {
    type Output = Quantity<isize, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for u8 {
    type Output = Quantity<u8, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for u16 {
    type Output = Quantity<u16, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for u32 {
    type Output = Quantity<u32, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for u64 {
    type Output = Quantity<u64, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for u128 {
    type Output = Quantity<u128, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for usize {
    type Output = Quantity<usize, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for f32 {
    type Output = Quantity<f32, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
impl Mul<UnitAttograysMul> for f64 {
    type Output = Quantity<f64, UnitAttograys>;
    fn mul(self, _: UnitAttograysMul) -> Self::Output {
        Quantity::new(self, UnitAttograys)
    }
}
pub struct UnitZeptograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptograys {
    #[inline]
    fn clone(&self) -> UnitZeptograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptograys {
    #[inline]
    fn eq(&self, other: &UnitZeptograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptograys {
    fn default() -> Self {
        UnitZeptograys
    }
}
impl Add<UnitZeptograys> for UnitZeptograys {
    type Output = UnitZeptograys;
    #[inline]
    fn add(self, _: UnitZeptograys) -> Self::Output {
        UnitZeptograys
    }
}
impl AddAssign<UnitZeptograys> for UnitZeptograys {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptograys) {}
}
impl Sub<UnitZeptograys> for UnitZeptograys {
    type Output = UnitZeptograys;
    #[inline]
    fn sub(self, _: UnitZeptograys) -> Self::Output {
        UnitZeptograys
    }
}
impl SubAssign<UnitZeptograys> for UnitZeptograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptograys) {}
}
pub struct UnitZeptograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptograysMul {
    #[inline]
    fn clone(&self) -> UnitZeptograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptograysMul {
    #[inline]
    fn eq(&self, other: &UnitZeptograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptograysMul> for i8 {
    type Output = Quantity<i8, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for i16 {
    type Output = Quantity<i16, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for i32 {
    type Output = Quantity<i32, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for i64 {
    type Output = Quantity<i64, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for i128 {
    type Output = Quantity<i128, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for isize {
    type Output = Quantity<isize, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for u8 {
    type Output = Quantity<u8, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for u16 {
    type Output = Quantity<u16, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for u32 {
    type Output = Quantity<u32, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for u64 {
    type Output = Quantity<u64, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for u128 {
    type Output = Quantity<u128, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for usize {
    type Output = Quantity<usize, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for f32 {
    type Output = Quantity<f32, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
impl Mul<UnitZeptograysMul> for f64 {
    type Output = Quantity<f64, UnitZeptograys>;
    fn mul(self, _: UnitZeptograysMul) -> Self::Output {
        Quantity::new(self, UnitZeptograys)
    }
}
pub struct UnitYoctograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctograys {
    #[inline]
    fn clone(&self) -> UnitYoctograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctograys {
    #[inline]
    fn eq(&self, other: &UnitYoctograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctograys {
    fn default() -> Self {
        UnitYoctograys
    }
}
impl Add<UnitYoctograys> for UnitYoctograys {
    type Output = UnitYoctograys;
    #[inline]
    fn add(self, _: UnitYoctograys) -> Self::Output {
        UnitYoctograys
    }
}
impl AddAssign<UnitYoctograys> for UnitYoctograys {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctograys) {}
}
impl Sub<UnitYoctograys> for UnitYoctograys {
    type Output = UnitYoctograys;
    #[inline]
    fn sub(self, _: UnitYoctograys) -> Self::Output {
        UnitYoctograys
    }
}
impl SubAssign<UnitYoctograys> for UnitYoctograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctograys) {}
}
pub struct UnitYoctograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctograysMul {
    #[inline]
    fn clone(&self) -> UnitYoctograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctograysMul {
    #[inline]
    fn eq(&self, other: &UnitYoctograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctograysMul> for i8 {
    type Output = Quantity<i8, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for i16 {
    type Output = Quantity<i16, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for i32 {
    type Output = Quantity<i32, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for i64 {
    type Output = Quantity<i64, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for i128 {
    type Output = Quantity<i128, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for isize {
    type Output = Quantity<isize, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for u8 {
    type Output = Quantity<u8, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for u16 {
    type Output = Quantity<u16, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for u32 {
    type Output = Quantity<u32, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for u64 {
    type Output = Quantity<u64, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for u128 {
    type Output = Quantity<u128, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for usize {
    type Output = Quantity<usize, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for f32 {
    type Output = Quantity<f32, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
impl Mul<UnitYoctograysMul> for f64 {
    type Output = Quantity<f64, UnitYoctograys>;
    fn mul(self, _: UnitYoctograysMul) -> Self::Output {
        Quantity::new(self, UnitYoctograys)
    }
}
pub struct UnitRontograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontograys {
    #[inline]
    fn clone(&self) -> UnitRontograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontograys {
    #[inline]
    fn eq(&self, other: &UnitRontograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontograys {
    fn default() -> Self {
        UnitRontograys
    }
}
impl Add<UnitRontograys> for UnitRontograys {
    type Output = UnitRontograys;
    #[inline]
    fn add(self, _: UnitRontograys) -> Self::Output {
        UnitRontograys
    }
}
impl AddAssign<UnitRontograys> for UnitRontograys {
    #[inline]
    fn add_assign(&mut self, _: UnitRontograys) {}
}
impl Sub<UnitRontograys> for UnitRontograys {
    type Output = UnitRontograys;
    #[inline]
    fn sub(self, _: UnitRontograys) -> Self::Output {
        UnitRontograys
    }
}
impl SubAssign<UnitRontograys> for UnitRontograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontograys) {}
}
pub struct UnitRontograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontograysMul {
    #[inline]
    fn clone(&self) -> UnitRontograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontograysMul {
    #[inline]
    fn eq(&self, other: &UnitRontograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontograysMul> for i8 {
    type Output = Quantity<i8, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for i16 {
    type Output = Quantity<i16, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for i32 {
    type Output = Quantity<i32, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for i64 {
    type Output = Quantity<i64, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for i128 {
    type Output = Quantity<i128, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for isize {
    type Output = Quantity<isize, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for u8 {
    type Output = Quantity<u8, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for u16 {
    type Output = Quantity<u16, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for u32 {
    type Output = Quantity<u32, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for u64 {
    type Output = Quantity<u64, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for u128 {
    type Output = Quantity<u128, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for usize {
    type Output = Quantity<usize, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for f32 {
    type Output = Quantity<f32, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
impl Mul<UnitRontograysMul> for f64 {
    type Output = Quantity<f64, UnitRontograys>;
    fn mul(self, _: UnitRontograysMul) -> Self::Output {
        Quantity::new(self, UnitRontograys)
    }
}
pub struct UnitQuectograys;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectograys {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectograys")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectograys {
    #[inline]
    fn clone(&self) -> UnitQuectograys {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectograys {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectograys {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectograys {
    #[inline]
    fn eq(&self, other: &UnitQuectograys) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectograys {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectograys {
    fn default() -> Self {
        UnitQuectograys
    }
}
impl Add<UnitQuectograys> for UnitQuectograys {
    type Output = UnitQuectograys;
    #[inline]
    fn add(self, _: UnitQuectograys) -> Self::Output {
        UnitQuectograys
    }
}
impl AddAssign<UnitQuectograys> for UnitQuectograys {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectograys) {}
}
impl Sub<UnitQuectograys> for UnitQuectograys {
    type Output = UnitQuectograys;
    #[inline]
    fn sub(self, _: UnitQuectograys) -> Self::Output {
        UnitQuectograys
    }
}
impl SubAssign<UnitQuectograys> for UnitQuectograys {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectograys) {}
}
pub struct UnitQuectograysMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectograysMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectograysMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectograysMul {
    #[inline]
    fn clone(&self) -> UnitQuectograysMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectograysMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectograysMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectograysMul {
    #[inline]
    fn eq(&self, other: &UnitQuectograysMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectograysMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectograysMul> for i8 {
    type Output = Quantity<i8, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for i16 {
    type Output = Quantity<i16, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for i32 {
    type Output = Quantity<i32, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for i64 {
    type Output = Quantity<i64, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for i128 {
    type Output = Quantity<i128, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for isize {
    type Output = Quantity<isize, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for u8 {
    type Output = Quantity<u8, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for u16 {
    type Output = Quantity<u16, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for u32 {
    type Output = Quantity<u32, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for u64 {
    type Output = Quantity<u64, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for u128 {
    type Output = Quantity<u128, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for usize {
    type Output = Quantity<usize, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for f32 {
    type Output = Quantity<f32, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
impl Mul<UnitQuectograysMul> for f64 {
    type Output = Quantity<f64, UnitQuectograys>;
    fn mul(self, _: UnitQuectograysMul) -> Self::Output {
        Quantity::new(self, UnitQuectograys)
    }
}
pub type Grays<T> = Quantity<T, UnitGrays>;
#[allow(non_upper_case_globals)]
pub static Grays: UnitGraysMul = UnitGraysMul;
pub type Quettagrays<T> = Quantity<T, UnitQuettagrays>;
#[allow(non_upper_case_globals)]
pub static Quettagrays: UnitQuettagraysMul = UnitQuettagraysMul;
pub type Ronnagrays<T> = Quantity<T, UnitRonnagrays>;
#[allow(non_upper_case_globals)]
pub static Ronnagrays: UnitRonnagraysMul = UnitRonnagraysMul;
pub type Yottagrays<T> = Quantity<T, UnitYottagrays>;
#[allow(non_upper_case_globals)]
pub static Yottagrays: UnitYottagraysMul = UnitYottagraysMul;
pub type Zettagrays<T> = Quantity<T, UnitZettagrays>;
#[allow(non_upper_case_globals)]
pub static Zettagrays: UnitZettagraysMul = UnitZettagraysMul;
pub type Exagrays<T> = Quantity<T, UnitExagrays>;
#[allow(non_upper_case_globals)]
pub static Exagrays: UnitExagraysMul = UnitExagraysMul;
pub type Petagrays<T> = Quantity<T, UnitPetagrays>;
#[allow(non_upper_case_globals)]
pub static Petagrays: UnitPetagraysMul = UnitPetagraysMul;
pub type Teragrays<T> = Quantity<T, UnitTeragrays>;
#[allow(non_upper_case_globals)]
pub static Teragrays: UnitTeragraysMul = UnitTeragraysMul;
pub type Gigagrays<T> = Quantity<T, UnitGigagrays>;
#[allow(non_upper_case_globals)]
pub static Gigagrays: UnitGigagraysMul = UnitGigagraysMul;
pub type Megagrays<T> = Quantity<T, UnitMegagrays>;
#[allow(non_upper_case_globals)]
pub static Megagrays: UnitMegagraysMul = UnitMegagraysMul;
pub type Kilograys<T> = Quantity<T, UnitKilograys>;
#[allow(non_upper_case_globals)]
pub static Kilograys: UnitKilograysMul = UnitKilograysMul;
pub type Hectograys<T> = Quantity<T, UnitHectograys>;
#[allow(non_upper_case_globals)]
pub static Hectograys: UnitHectograysMul = UnitHectograysMul;
pub type Decagrays<T> = Quantity<T, UnitDecagrays>;
#[allow(non_upper_case_globals)]
pub static Decagrays: UnitDecagraysMul = UnitDecagraysMul;
pub type Decigrays<T> = Quantity<T, UnitDecigrays>;
#[allow(non_upper_case_globals)]
pub static Decigrays: UnitDecigraysMul = UnitDecigraysMul;
pub type Centigrays<T> = Quantity<T, UnitCentigrays>;
#[allow(non_upper_case_globals)]
pub static Centigrays: UnitCentigraysMul = UnitCentigraysMul;
pub type Milligrays<T> = Quantity<T, UnitMilligrays>;
#[allow(non_upper_case_globals)]
pub static Milligrays: UnitMilligraysMul = UnitMilligraysMul;
pub type Micrograys<T> = Quantity<T, UnitMicrograys>;
#[allow(non_upper_case_globals)]
pub static Micrograys: UnitMicrograysMul = UnitMicrograysMul;
pub type Nanograys<T> = Quantity<T, UnitNanograys>;
#[allow(non_upper_case_globals)]
pub static Nanograys: UnitNanograysMul = UnitNanograysMul;
pub type Picograys<T> = Quantity<T, UnitPicograys>;
#[allow(non_upper_case_globals)]
pub static Picograys: UnitPicograysMul = UnitPicograysMul;
pub type Femtograys<T> = Quantity<T, UnitFemtograys>;
#[allow(non_upper_case_globals)]
pub static Femtograys: UnitFemtograysMul = UnitFemtograysMul;
pub type Attograys<T> = Quantity<T, UnitAttograys>;
#[allow(non_upper_case_globals)]
pub static Attograys: UnitAttograysMul = UnitAttograysMul;
pub type Zeptograys<T> = Quantity<T, UnitZeptograys>;
#[allow(non_upper_case_globals)]
pub static Zeptograys: UnitZeptograysMul = UnitZeptograysMul;
pub type Yoctograys<T> = Quantity<T, UnitYoctograys>;
#[allow(non_upper_case_globals)]
pub static Yoctograys: UnitYoctograysMul = UnitYoctograysMul;
pub type Rontograys<T> = Quantity<T, UnitRontograys>;
#[allow(non_upper_case_globals)]
pub static Rontograys: UnitRontograysMul = UnitRontograysMul;
pub type Quectograys<T> = Quantity<T, UnitQuectograys>;
#[allow(non_upper_case_globals)]
pub static Quectograys: UnitQuectograysMul = UnitQuectograysMul;
pub struct UnitSieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSieverts {
    #[inline]
    fn clone(&self) -> UnitSieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSieverts {
    #[inline]
    fn eq(&self, other: &UnitSieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitSieverts {
    fn default() -> Self {
        UnitSieverts
    }
}
impl Add<UnitSieverts> for UnitSieverts {
    type Output = UnitSieverts;
    #[inline]
    fn add(self, _: UnitSieverts) -> Self::Output {
        UnitSieverts
    }
}
impl AddAssign<UnitSieverts> for UnitSieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitSieverts) {}
}
impl Sub<UnitSieverts> for UnitSieverts {
    type Output = UnitSieverts;
    #[inline]
    fn sub(self, _: UnitSieverts) -> Self::Output {
        UnitSieverts
    }
}
impl SubAssign<UnitSieverts> for UnitSieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitSieverts) {}
}
pub struct UnitSievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitSievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitSievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitSievertsMul {
    #[inline]
    fn clone(&self) -> UnitSievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitSievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitSievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitSievertsMul {
    #[inline]
    fn eq(&self, other: &UnitSievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitSievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitSievertsMul> for i8 {
    type Output = Quantity<i8, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for i16 {
    type Output = Quantity<i16, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for i32 {
    type Output = Quantity<i32, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for i64 {
    type Output = Quantity<i64, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for i128 {
    type Output = Quantity<i128, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for isize {
    type Output = Quantity<isize, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for u8 {
    type Output = Quantity<u8, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for u16 {
    type Output = Quantity<u16, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for u32 {
    type Output = Quantity<u32, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for u64 {
    type Output = Quantity<u64, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for u128 {
    type Output = Quantity<u128, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for usize {
    type Output = Quantity<usize, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for f32 {
    type Output = Quantity<f32, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
impl Mul<UnitSievertsMul> for f64 {
    type Output = Quantity<f64, UnitSieverts>;
    fn mul(self, _: UnitSievertsMul) -> Self::Output {
        Quantity::new(self, UnitSieverts)
    }
}
pub struct UnitQuettasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasieverts {
    #[inline]
    fn clone(&self) -> UnitQuettasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasieverts {
    #[inline]
    fn eq(&self, other: &UnitQuettasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettasieverts {
    fn default() -> Self {
        UnitQuettasieverts
    }
}
impl Add<UnitQuettasieverts> for UnitQuettasieverts {
    type Output = UnitQuettasieverts;
    #[inline]
    fn add(self, _: UnitQuettasieverts) -> Self::Output {
        UnitQuettasieverts
    }
}
impl AddAssign<UnitQuettasieverts> for UnitQuettasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettasieverts) {}
}
impl Sub<UnitQuettasieverts> for UnitQuettasieverts {
    type Output = UnitQuettasieverts;
    #[inline]
    fn sub(self, _: UnitQuettasieverts) -> Self::Output {
        UnitQuettasieverts
    }
}
impl SubAssign<UnitQuettasieverts> for UnitQuettasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettasieverts) {}
}
pub struct UnitQuettasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettasievertsMul {
    #[inline]
    fn clone(&self) -> UnitQuettasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettasievertsMul> for i8 {
    type Output = Quantity<i8, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for i16 {
    type Output = Quantity<i16, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for i32 {
    type Output = Quantity<i32, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for i64 {
    type Output = Quantity<i64, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for i128 {
    type Output = Quantity<i128, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for isize {
    type Output = Quantity<isize, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for u8 {
    type Output = Quantity<u8, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for u16 {
    type Output = Quantity<u16, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for u32 {
    type Output = Quantity<u32, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for u64 {
    type Output = Quantity<u64, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for u128 {
    type Output = Quantity<u128, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for usize {
    type Output = Quantity<usize, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for f32 {
    type Output = Quantity<f32, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
impl Mul<UnitQuettasievertsMul> for f64 {
    type Output = Quantity<f64, UnitQuettasieverts>;
    fn mul(self, _: UnitQuettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuettasieverts)
    }
}
pub struct UnitRonnasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasieverts {
    #[inline]
    fn clone(&self) -> UnitRonnasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasieverts {
    #[inline]
    fn eq(&self, other: &UnitRonnasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnasieverts {
    fn default() -> Self {
        UnitRonnasieverts
    }
}
impl Add<UnitRonnasieverts> for UnitRonnasieverts {
    type Output = UnitRonnasieverts;
    #[inline]
    fn add(self, _: UnitRonnasieverts) -> Self::Output {
        UnitRonnasieverts
    }
}
impl AddAssign<UnitRonnasieverts> for UnitRonnasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnasieverts) {}
}
impl Sub<UnitRonnasieverts> for UnitRonnasieverts {
    type Output = UnitRonnasieverts;
    #[inline]
    fn sub(self, _: UnitRonnasieverts) -> Self::Output {
        UnitRonnasieverts
    }
}
impl SubAssign<UnitRonnasieverts> for UnitRonnasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnasieverts) {}
}
pub struct UnitRonnasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnasievertsMul {
    #[inline]
    fn clone(&self) -> UnitRonnasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnasievertsMul> for i8 {
    type Output = Quantity<i8, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for i16 {
    type Output = Quantity<i16, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for i32 {
    type Output = Quantity<i32, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for i64 {
    type Output = Quantity<i64, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for i128 {
    type Output = Quantity<i128, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for isize {
    type Output = Quantity<isize, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for u8 {
    type Output = Quantity<u8, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for u16 {
    type Output = Quantity<u16, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for u32 {
    type Output = Quantity<u32, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for u64 {
    type Output = Quantity<u64, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for u128 {
    type Output = Quantity<u128, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for usize {
    type Output = Quantity<usize, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for f32 {
    type Output = Quantity<f32, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
impl Mul<UnitRonnasievertsMul> for f64 {
    type Output = Quantity<f64, UnitRonnasieverts>;
    fn mul(self, _: UnitRonnasievertsMul) -> Self::Output {
        Quantity::new(self, UnitRonnasieverts)
    }
}
pub struct UnitYottasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasieverts {
    #[inline]
    fn clone(&self) -> UnitYottasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasieverts {
    #[inline]
    fn eq(&self, other: &UnitYottasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottasieverts {
    fn default() -> Self {
        UnitYottasieverts
    }
}
impl Add<UnitYottasieverts> for UnitYottasieverts {
    type Output = UnitYottasieverts;
    #[inline]
    fn add(self, _: UnitYottasieverts) -> Self::Output {
        UnitYottasieverts
    }
}
impl AddAssign<UnitYottasieverts> for UnitYottasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitYottasieverts) {}
}
impl Sub<UnitYottasieverts> for UnitYottasieverts {
    type Output = UnitYottasieverts;
    #[inline]
    fn sub(self, _: UnitYottasieverts) -> Self::Output {
        UnitYottasieverts
    }
}
impl SubAssign<UnitYottasieverts> for UnitYottasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottasieverts) {}
}
pub struct UnitYottasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottasievertsMul {
    #[inline]
    fn clone(&self) -> UnitYottasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitYottasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottasievertsMul> for i8 {
    type Output = Quantity<i8, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for i16 {
    type Output = Quantity<i16, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for i32 {
    type Output = Quantity<i32, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for i64 {
    type Output = Quantity<i64, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for i128 {
    type Output = Quantity<i128, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for isize {
    type Output = Quantity<isize, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for u8 {
    type Output = Quantity<u8, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for u16 {
    type Output = Quantity<u16, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for u32 {
    type Output = Quantity<u32, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for u64 {
    type Output = Quantity<u64, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for u128 {
    type Output = Quantity<u128, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for usize {
    type Output = Quantity<usize, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for f32 {
    type Output = Quantity<f32, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
impl Mul<UnitYottasievertsMul> for f64 {
    type Output = Quantity<f64, UnitYottasieverts>;
    fn mul(self, _: UnitYottasievertsMul) -> Self::Output {
        Quantity::new(self, UnitYottasieverts)
    }
}
pub struct UnitZettasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasieverts {
    #[inline]
    fn clone(&self) -> UnitZettasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasieverts {
    #[inline]
    fn eq(&self, other: &UnitZettasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettasieverts {
    fn default() -> Self {
        UnitZettasieverts
    }
}
impl Add<UnitZettasieverts> for UnitZettasieverts {
    type Output = UnitZettasieverts;
    #[inline]
    fn add(self, _: UnitZettasieverts) -> Self::Output {
        UnitZettasieverts
    }
}
impl AddAssign<UnitZettasieverts> for UnitZettasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitZettasieverts) {}
}
impl Sub<UnitZettasieverts> for UnitZettasieverts {
    type Output = UnitZettasieverts;
    #[inline]
    fn sub(self, _: UnitZettasieverts) -> Self::Output {
        UnitZettasieverts
    }
}
impl SubAssign<UnitZettasieverts> for UnitZettasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettasieverts) {}
}
pub struct UnitZettasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettasievertsMul {
    #[inline]
    fn clone(&self) -> UnitZettasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitZettasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettasievertsMul> for i8 {
    type Output = Quantity<i8, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for i16 {
    type Output = Quantity<i16, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for i32 {
    type Output = Quantity<i32, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for i64 {
    type Output = Quantity<i64, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for i128 {
    type Output = Quantity<i128, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for isize {
    type Output = Quantity<isize, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for u8 {
    type Output = Quantity<u8, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for u16 {
    type Output = Quantity<u16, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for u32 {
    type Output = Quantity<u32, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for u64 {
    type Output = Quantity<u64, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for u128 {
    type Output = Quantity<u128, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for usize {
    type Output = Quantity<usize, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for f32 {
    type Output = Quantity<f32, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
impl Mul<UnitZettasievertsMul> for f64 {
    type Output = Quantity<f64, UnitZettasieverts>;
    fn mul(self, _: UnitZettasievertsMul) -> Self::Output {
        Quantity::new(self, UnitZettasieverts)
    }
}
pub struct UnitExasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasieverts {
    #[inline]
    fn clone(&self) -> UnitExasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasieverts {
    #[inline]
    fn eq(&self, other: &UnitExasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExasieverts {
    fn default() -> Self {
        UnitExasieverts
    }
}
impl Add<UnitExasieverts> for UnitExasieverts {
    type Output = UnitExasieverts;
    #[inline]
    fn add(self, _: UnitExasieverts) -> Self::Output {
        UnitExasieverts
    }
}
impl AddAssign<UnitExasieverts> for UnitExasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitExasieverts) {}
}
impl Sub<UnitExasieverts> for UnitExasieverts {
    type Output = UnitExasieverts;
    #[inline]
    fn sub(self, _: UnitExasieverts) -> Self::Output {
        UnitExasieverts
    }
}
impl SubAssign<UnitExasieverts> for UnitExasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitExasieverts) {}
}
pub struct UnitExasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExasievertsMul {
    #[inline]
    fn clone(&self) -> UnitExasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitExasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExasievertsMul> for i8 {
    type Output = Quantity<i8, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for i16 {
    type Output = Quantity<i16, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for i32 {
    type Output = Quantity<i32, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for i64 {
    type Output = Quantity<i64, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for i128 {
    type Output = Quantity<i128, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for isize {
    type Output = Quantity<isize, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for u8 {
    type Output = Quantity<u8, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for u16 {
    type Output = Quantity<u16, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for u32 {
    type Output = Quantity<u32, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for u64 {
    type Output = Quantity<u64, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for u128 {
    type Output = Quantity<u128, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for usize {
    type Output = Quantity<usize, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for f32 {
    type Output = Quantity<f32, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
impl Mul<UnitExasievertsMul> for f64 {
    type Output = Quantity<f64, UnitExasieverts>;
    fn mul(self, _: UnitExasievertsMul) -> Self::Output {
        Quantity::new(self, UnitExasieverts)
    }
}
pub struct UnitPetasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasieverts {
    #[inline]
    fn clone(&self) -> UnitPetasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasieverts {
    #[inline]
    fn eq(&self, other: &UnitPetasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetasieverts {
    fn default() -> Self {
        UnitPetasieverts
    }
}
impl Add<UnitPetasieverts> for UnitPetasieverts {
    type Output = UnitPetasieverts;
    #[inline]
    fn add(self, _: UnitPetasieverts) -> Self::Output {
        UnitPetasieverts
    }
}
impl AddAssign<UnitPetasieverts> for UnitPetasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitPetasieverts) {}
}
impl Sub<UnitPetasieverts> for UnitPetasieverts {
    type Output = UnitPetasieverts;
    #[inline]
    fn sub(self, _: UnitPetasieverts) -> Self::Output {
        UnitPetasieverts
    }
}
impl SubAssign<UnitPetasieverts> for UnitPetasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetasieverts) {}
}
pub struct UnitPetasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetasievertsMul {
    #[inline]
    fn clone(&self) -> UnitPetasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitPetasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetasievertsMul> for i8 {
    type Output = Quantity<i8, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for i16 {
    type Output = Quantity<i16, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for i32 {
    type Output = Quantity<i32, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for i64 {
    type Output = Quantity<i64, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for i128 {
    type Output = Quantity<i128, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for isize {
    type Output = Quantity<isize, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for u8 {
    type Output = Quantity<u8, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for u16 {
    type Output = Quantity<u16, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for u32 {
    type Output = Quantity<u32, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for u64 {
    type Output = Quantity<u64, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for u128 {
    type Output = Quantity<u128, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for usize {
    type Output = Quantity<usize, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for f32 {
    type Output = Quantity<f32, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
impl Mul<UnitPetasievertsMul> for f64 {
    type Output = Quantity<f64, UnitPetasieverts>;
    fn mul(self, _: UnitPetasievertsMul) -> Self::Output {
        Quantity::new(self, UnitPetasieverts)
    }
}
pub struct UnitTerasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasieverts {
    #[inline]
    fn clone(&self) -> UnitTerasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasieverts {
    #[inline]
    fn eq(&self, other: &UnitTerasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerasieverts {
    fn default() -> Self {
        UnitTerasieverts
    }
}
impl Add<UnitTerasieverts> for UnitTerasieverts {
    type Output = UnitTerasieverts;
    #[inline]
    fn add(self, _: UnitTerasieverts) -> Self::Output {
        UnitTerasieverts
    }
}
impl AddAssign<UnitTerasieverts> for UnitTerasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitTerasieverts) {}
}
impl Sub<UnitTerasieverts> for UnitTerasieverts {
    type Output = UnitTerasieverts;
    #[inline]
    fn sub(self, _: UnitTerasieverts) -> Self::Output {
        UnitTerasieverts
    }
}
impl SubAssign<UnitTerasieverts> for UnitTerasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerasieverts) {}
}
pub struct UnitTerasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerasievertsMul {
    #[inline]
    fn clone(&self) -> UnitTerasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitTerasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerasievertsMul> for i8 {
    type Output = Quantity<i8, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for i16 {
    type Output = Quantity<i16, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for i32 {
    type Output = Quantity<i32, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for i64 {
    type Output = Quantity<i64, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for i128 {
    type Output = Quantity<i128, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for isize {
    type Output = Quantity<isize, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for u8 {
    type Output = Quantity<u8, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for u16 {
    type Output = Quantity<u16, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for u32 {
    type Output = Quantity<u32, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for u64 {
    type Output = Quantity<u64, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for u128 {
    type Output = Quantity<u128, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for usize {
    type Output = Quantity<usize, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for f32 {
    type Output = Quantity<f32, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
impl Mul<UnitTerasievertsMul> for f64 {
    type Output = Quantity<f64, UnitTerasieverts>;
    fn mul(self, _: UnitTerasievertsMul) -> Self::Output {
        Quantity::new(self, UnitTerasieverts)
    }
}
pub struct UnitGigasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasieverts {
    #[inline]
    fn clone(&self) -> UnitGigasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasieverts {
    #[inline]
    fn eq(&self, other: &UnitGigasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigasieverts {
    fn default() -> Self {
        UnitGigasieverts
    }
}
impl Add<UnitGigasieverts> for UnitGigasieverts {
    type Output = UnitGigasieverts;
    #[inline]
    fn add(self, _: UnitGigasieverts) -> Self::Output {
        UnitGigasieverts
    }
}
impl AddAssign<UnitGigasieverts> for UnitGigasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitGigasieverts) {}
}
impl Sub<UnitGigasieverts> for UnitGigasieverts {
    type Output = UnitGigasieverts;
    #[inline]
    fn sub(self, _: UnitGigasieverts) -> Self::Output {
        UnitGigasieverts
    }
}
impl SubAssign<UnitGigasieverts> for UnitGigasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigasieverts) {}
}
pub struct UnitGigasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigasievertsMul {
    #[inline]
    fn clone(&self) -> UnitGigasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitGigasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigasievertsMul> for i8 {
    type Output = Quantity<i8, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for i16 {
    type Output = Quantity<i16, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for i32 {
    type Output = Quantity<i32, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for i64 {
    type Output = Quantity<i64, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for i128 {
    type Output = Quantity<i128, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for isize {
    type Output = Quantity<isize, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for u8 {
    type Output = Quantity<u8, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for u16 {
    type Output = Quantity<u16, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for u32 {
    type Output = Quantity<u32, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for u64 {
    type Output = Quantity<u64, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for u128 {
    type Output = Quantity<u128, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for usize {
    type Output = Quantity<usize, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for f32 {
    type Output = Quantity<f32, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
impl Mul<UnitGigasievertsMul> for f64 {
    type Output = Quantity<f64, UnitGigasieverts>;
    fn mul(self, _: UnitGigasievertsMul) -> Self::Output {
        Quantity::new(self, UnitGigasieverts)
    }
}
pub struct UnitMegasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasieverts {
    #[inline]
    fn clone(&self) -> UnitMegasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasieverts {
    #[inline]
    fn eq(&self, other: &UnitMegasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegasieverts {
    fn default() -> Self {
        UnitMegasieverts
    }
}
impl Add<UnitMegasieverts> for UnitMegasieverts {
    type Output = UnitMegasieverts;
    #[inline]
    fn add(self, _: UnitMegasieverts) -> Self::Output {
        UnitMegasieverts
    }
}
impl AddAssign<UnitMegasieverts> for UnitMegasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitMegasieverts) {}
}
impl Sub<UnitMegasieverts> for UnitMegasieverts {
    type Output = UnitMegasieverts;
    #[inline]
    fn sub(self, _: UnitMegasieverts) -> Self::Output {
        UnitMegasieverts
    }
}
impl SubAssign<UnitMegasieverts> for UnitMegasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegasieverts) {}
}
pub struct UnitMegasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegasievertsMul {
    #[inline]
    fn clone(&self) -> UnitMegasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitMegasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegasievertsMul> for i8 {
    type Output = Quantity<i8, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for i16 {
    type Output = Quantity<i16, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for i32 {
    type Output = Quantity<i32, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for i64 {
    type Output = Quantity<i64, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for i128 {
    type Output = Quantity<i128, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for isize {
    type Output = Quantity<isize, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for u8 {
    type Output = Quantity<u8, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for u16 {
    type Output = Quantity<u16, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for u32 {
    type Output = Quantity<u32, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for u64 {
    type Output = Quantity<u64, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for u128 {
    type Output = Quantity<u128, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for usize {
    type Output = Quantity<usize, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for f32 {
    type Output = Quantity<f32, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
impl Mul<UnitMegasievertsMul> for f64 {
    type Output = Quantity<f64, UnitMegasieverts>;
    fn mul(self, _: UnitMegasievertsMul) -> Self::Output {
        Quantity::new(self, UnitMegasieverts)
    }
}
pub struct UnitKilosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosieverts {
    #[inline]
    fn clone(&self) -> UnitKilosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosieverts {
    #[inline]
    fn eq(&self, other: &UnitKilosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilosieverts {
    fn default() -> Self {
        UnitKilosieverts
    }
}
impl Add<UnitKilosieverts> for UnitKilosieverts {
    type Output = UnitKilosieverts;
    #[inline]
    fn add(self, _: UnitKilosieverts) -> Self::Output {
        UnitKilosieverts
    }
}
impl AddAssign<UnitKilosieverts> for UnitKilosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitKilosieverts) {}
}
impl Sub<UnitKilosieverts> for UnitKilosieverts {
    type Output = UnitKilosieverts;
    #[inline]
    fn sub(self, _: UnitKilosieverts) -> Self::Output {
        UnitKilosieverts
    }
}
impl SubAssign<UnitKilosieverts> for UnitKilosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilosieverts) {}
}
pub struct UnitKilosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilosievertsMul {
    #[inline]
    fn clone(&self) -> UnitKilosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitKilosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilosievertsMul> for i8 {
    type Output = Quantity<i8, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for i16 {
    type Output = Quantity<i16, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for i32 {
    type Output = Quantity<i32, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for i64 {
    type Output = Quantity<i64, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for i128 {
    type Output = Quantity<i128, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for isize {
    type Output = Quantity<isize, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for u8 {
    type Output = Quantity<u8, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for u16 {
    type Output = Quantity<u16, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for u32 {
    type Output = Quantity<u32, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for u64 {
    type Output = Quantity<u64, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for u128 {
    type Output = Quantity<u128, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for usize {
    type Output = Quantity<usize, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for f32 {
    type Output = Quantity<f32, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
impl Mul<UnitKilosievertsMul> for f64 {
    type Output = Quantity<f64, UnitKilosieverts>;
    fn mul(self, _: UnitKilosievertsMul) -> Self::Output {
        Quantity::new(self, UnitKilosieverts)
    }
}
pub struct UnitHectosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosieverts {
    #[inline]
    fn clone(&self) -> UnitHectosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosieverts {
    #[inline]
    fn eq(&self, other: &UnitHectosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectosieverts {
    fn default() -> Self {
        UnitHectosieverts
    }
}
impl Add<UnitHectosieverts> for UnitHectosieverts {
    type Output = UnitHectosieverts;
    #[inline]
    fn add(self, _: UnitHectosieverts) -> Self::Output {
        UnitHectosieverts
    }
}
impl AddAssign<UnitHectosieverts> for UnitHectosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitHectosieverts) {}
}
impl Sub<UnitHectosieverts> for UnitHectosieverts {
    type Output = UnitHectosieverts;
    #[inline]
    fn sub(self, _: UnitHectosieverts) -> Self::Output {
        UnitHectosieverts
    }
}
impl SubAssign<UnitHectosieverts> for UnitHectosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectosieverts) {}
}
pub struct UnitHectosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectosievertsMul {
    #[inline]
    fn clone(&self) -> UnitHectosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitHectosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectosievertsMul> for i8 {
    type Output = Quantity<i8, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for i16 {
    type Output = Quantity<i16, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for i32 {
    type Output = Quantity<i32, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for i64 {
    type Output = Quantity<i64, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for i128 {
    type Output = Quantity<i128, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for isize {
    type Output = Quantity<isize, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for u8 {
    type Output = Quantity<u8, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for u16 {
    type Output = Quantity<u16, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for u32 {
    type Output = Quantity<u32, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for u64 {
    type Output = Quantity<u64, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for u128 {
    type Output = Quantity<u128, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for usize {
    type Output = Quantity<usize, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for f32 {
    type Output = Quantity<f32, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
impl Mul<UnitHectosievertsMul> for f64 {
    type Output = Quantity<f64, UnitHectosieverts>;
    fn mul(self, _: UnitHectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitHectosieverts)
    }
}
pub struct UnitDecasieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasieverts {
    #[inline]
    fn clone(&self) -> UnitDecasieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasieverts {
    #[inline]
    fn eq(&self, other: &UnitDecasieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecasieverts {
    fn default() -> Self {
        UnitDecasieverts
    }
}
impl Add<UnitDecasieverts> for UnitDecasieverts {
    type Output = UnitDecasieverts;
    #[inline]
    fn add(self, _: UnitDecasieverts) -> Self::Output {
        UnitDecasieverts
    }
}
impl AddAssign<UnitDecasieverts> for UnitDecasieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitDecasieverts) {}
}
impl Sub<UnitDecasieverts> for UnitDecasieverts {
    type Output = UnitDecasieverts;
    #[inline]
    fn sub(self, _: UnitDecasieverts) -> Self::Output {
        UnitDecasieverts
    }
}
impl SubAssign<UnitDecasieverts> for UnitDecasieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecasieverts) {}
}
pub struct UnitDecasievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecasievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecasievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecasievertsMul {
    #[inline]
    fn clone(&self) -> UnitDecasievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecasievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecasievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecasievertsMul {
    #[inline]
    fn eq(&self, other: &UnitDecasievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecasievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecasievertsMul> for i8 {
    type Output = Quantity<i8, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for i16 {
    type Output = Quantity<i16, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for i32 {
    type Output = Quantity<i32, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for i64 {
    type Output = Quantity<i64, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for i128 {
    type Output = Quantity<i128, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for isize {
    type Output = Quantity<isize, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for u8 {
    type Output = Quantity<u8, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for u16 {
    type Output = Quantity<u16, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for u32 {
    type Output = Quantity<u32, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for u64 {
    type Output = Quantity<u64, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for u128 {
    type Output = Quantity<u128, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for usize {
    type Output = Quantity<usize, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for f32 {
    type Output = Quantity<f32, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
impl Mul<UnitDecasievertsMul> for f64 {
    type Output = Quantity<f64, UnitDecasieverts>;
    fn mul(self, _: UnitDecasievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecasieverts)
    }
}
pub struct UnitDecisieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisieverts {
    #[inline]
    fn clone(&self) -> UnitDecisieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisieverts {
    #[inline]
    fn eq(&self, other: &UnitDecisieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecisieverts {
    fn default() -> Self {
        UnitDecisieverts
    }
}
impl Add<UnitDecisieverts> for UnitDecisieverts {
    type Output = UnitDecisieverts;
    #[inline]
    fn add(self, _: UnitDecisieverts) -> Self::Output {
        UnitDecisieverts
    }
}
impl AddAssign<UnitDecisieverts> for UnitDecisieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitDecisieverts) {}
}
impl Sub<UnitDecisieverts> for UnitDecisieverts {
    type Output = UnitDecisieverts;
    #[inline]
    fn sub(self, _: UnitDecisieverts) -> Self::Output {
        UnitDecisieverts
    }
}
impl SubAssign<UnitDecisieverts> for UnitDecisieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecisieverts) {}
}
pub struct UnitDecisievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecisievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecisievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecisievertsMul {
    #[inline]
    fn clone(&self) -> UnitDecisievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecisievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecisievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecisievertsMul {
    #[inline]
    fn eq(&self, other: &UnitDecisievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecisievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecisievertsMul> for i8 {
    type Output = Quantity<i8, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for i16 {
    type Output = Quantity<i16, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for i32 {
    type Output = Quantity<i32, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for i64 {
    type Output = Quantity<i64, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for i128 {
    type Output = Quantity<i128, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for isize {
    type Output = Quantity<isize, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for u8 {
    type Output = Quantity<u8, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for u16 {
    type Output = Quantity<u16, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for u32 {
    type Output = Quantity<u32, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for u64 {
    type Output = Quantity<u64, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for u128 {
    type Output = Quantity<u128, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for usize {
    type Output = Quantity<usize, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for f32 {
    type Output = Quantity<f32, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
impl Mul<UnitDecisievertsMul> for f64 {
    type Output = Quantity<f64, UnitDecisieverts>;
    fn mul(self, _: UnitDecisievertsMul) -> Self::Output {
        Quantity::new(self, UnitDecisieverts)
    }
}
pub struct UnitCentisieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisieverts {
    #[inline]
    fn clone(&self) -> UnitCentisieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisieverts {
    #[inline]
    fn eq(&self, other: &UnitCentisieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentisieverts {
    fn default() -> Self {
        UnitCentisieverts
    }
}
impl Add<UnitCentisieverts> for UnitCentisieverts {
    type Output = UnitCentisieverts;
    #[inline]
    fn add(self, _: UnitCentisieverts) -> Self::Output {
        UnitCentisieverts
    }
}
impl AddAssign<UnitCentisieverts> for UnitCentisieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitCentisieverts) {}
}
impl Sub<UnitCentisieverts> for UnitCentisieverts {
    type Output = UnitCentisieverts;
    #[inline]
    fn sub(self, _: UnitCentisieverts) -> Self::Output {
        UnitCentisieverts
    }
}
impl SubAssign<UnitCentisieverts> for UnitCentisieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentisieverts) {}
}
pub struct UnitCentisievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentisievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentisievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentisievertsMul {
    #[inline]
    fn clone(&self) -> UnitCentisievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentisievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentisievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentisievertsMul {
    #[inline]
    fn eq(&self, other: &UnitCentisievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentisievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentisievertsMul> for i8 {
    type Output = Quantity<i8, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for i16 {
    type Output = Quantity<i16, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for i32 {
    type Output = Quantity<i32, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for i64 {
    type Output = Quantity<i64, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for i128 {
    type Output = Quantity<i128, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for isize {
    type Output = Quantity<isize, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for u8 {
    type Output = Quantity<u8, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for u16 {
    type Output = Quantity<u16, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for u32 {
    type Output = Quantity<u32, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for u64 {
    type Output = Quantity<u64, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for u128 {
    type Output = Quantity<u128, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for usize {
    type Output = Quantity<usize, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for f32 {
    type Output = Quantity<f32, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
impl Mul<UnitCentisievertsMul> for f64 {
    type Output = Quantity<f64, UnitCentisieverts>;
    fn mul(self, _: UnitCentisievertsMul) -> Self::Output {
        Quantity::new(self, UnitCentisieverts)
    }
}
pub struct UnitMillisieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisieverts {
    #[inline]
    fn clone(&self) -> UnitMillisieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisieverts {
    #[inline]
    fn eq(&self, other: &UnitMillisieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillisieverts {
    fn default() -> Self {
        UnitMillisieverts
    }
}
impl Add<UnitMillisieverts> for UnitMillisieverts {
    type Output = UnitMillisieverts;
    #[inline]
    fn add(self, _: UnitMillisieverts) -> Self::Output {
        UnitMillisieverts
    }
}
impl AddAssign<UnitMillisieverts> for UnitMillisieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitMillisieverts) {}
}
impl Sub<UnitMillisieverts> for UnitMillisieverts {
    type Output = UnitMillisieverts;
    #[inline]
    fn sub(self, _: UnitMillisieverts) -> Self::Output {
        UnitMillisieverts
    }
}
impl SubAssign<UnitMillisieverts> for UnitMillisieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillisieverts) {}
}
pub struct UnitMillisievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillisievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillisievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillisievertsMul {
    #[inline]
    fn clone(&self) -> UnitMillisievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillisievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillisievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillisievertsMul {
    #[inline]
    fn eq(&self, other: &UnitMillisievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillisievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillisievertsMul> for i8 {
    type Output = Quantity<i8, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for i16 {
    type Output = Quantity<i16, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for i32 {
    type Output = Quantity<i32, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for i64 {
    type Output = Quantity<i64, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for i128 {
    type Output = Quantity<i128, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for isize {
    type Output = Quantity<isize, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for u8 {
    type Output = Quantity<u8, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for u16 {
    type Output = Quantity<u16, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for u32 {
    type Output = Quantity<u32, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for u64 {
    type Output = Quantity<u64, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for u128 {
    type Output = Quantity<u128, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for usize {
    type Output = Quantity<usize, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for f32 {
    type Output = Quantity<f32, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
impl Mul<UnitMillisievertsMul> for f64 {
    type Output = Quantity<f64, UnitMillisieverts>;
    fn mul(self, _: UnitMillisievertsMul) -> Self::Output {
        Quantity::new(self, UnitMillisieverts)
    }
}
pub struct UnitMicrosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosieverts {
    #[inline]
    fn clone(&self) -> UnitMicrosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosieverts {
    #[inline]
    fn eq(&self, other: &UnitMicrosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrosieverts {
    fn default() -> Self {
        UnitMicrosieverts
    }
}
impl Add<UnitMicrosieverts> for UnitMicrosieverts {
    type Output = UnitMicrosieverts;
    #[inline]
    fn add(self, _: UnitMicrosieverts) -> Self::Output {
        UnitMicrosieverts
    }
}
impl AddAssign<UnitMicrosieverts> for UnitMicrosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrosieverts) {}
}
impl Sub<UnitMicrosieverts> for UnitMicrosieverts {
    type Output = UnitMicrosieverts;
    #[inline]
    fn sub(self, _: UnitMicrosieverts) -> Self::Output {
        UnitMicrosieverts
    }
}
impl SubAssign<UnitMicrosieverts> for UnitMicrosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrosieverts) {}
}
pub struct UnitMicrosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrosievertsMul {
    #[inline]
    fn clone(&self) -> UnitMicrosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrosievertsMul> for i8 {
    type Output = Quantity<i8, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for i16 {
    type Output = Quantity<i16, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for i32 {
    type Output = Quantity<i32, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for i64 {
    type Output = Quantity<i64, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for i128 {
    type Output = Quantity<i128, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for isize {
    type Output = Quantity<isize, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for u8 {
    type Output = Quantity<u8, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for u16 {
    type Output = Quantity<u16, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for u32 {
    type Output = Quantity<u32, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for u64 {
    type Output = Quantity<u64, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for u128 {
    type Output = Quantity<u128, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for usize {
    type Output = Quantity<usize, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for f32 {
    type Output = Quantity<f32, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
impl Mul<UnitMicrosievertsMul> for f64 {
    type Output = Quantity<f64, UnitMicrosieverts>;
    fn mul(self, _: UnitMicrosievertsMul) -> Self::Output {
        Quantity::new(self, UnitMicrosieverts)
    }
}
pub struct UnitNanosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosieverts {
    #[inline]
    fn clone(&self) -> UnitNanosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosieverts {
    #[inline]
    fn eq(&self, other: &UnitNanosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanosieverts {
    fn default() -> Self {
        UnitNanosieverts
    }
}
impl Add<UnitNanosieverts> for UnitNanosieverts {
    type Output = UnitNanosieverts;
    #[inline]
    fn add(self, _: UnitNanosieverts) -> Self::Output {
        UnitNanosieverts
    }
}
impl AddAssign<UnitNanosieverts> for UnitNanosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitNanosieverts) {}
}
impl Sub<UnitNanosieverts> for UnitNanosieverts {
    type Output = UnitNanosieverts;
    #[inline]
    fn sub(self, _: UnitNanosieverts) -> Self::Output {
        UnitNanosieverts
    }
}
impl SubAssign<UnitNanosieverts> for UnitNanosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanosieverts) {}
}
pub struct UnitNanosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanosievertsMul {
    #[inline]
    fn clone(&self) -> UnitNanosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitNanosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanosievertsMul> for i8 {
    type Output = Quantity<i8, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for i16 {
    type Output = Quantity<i16, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for i32 {
    type Output = Quantity<i32, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for i64 {
    type Output = Quantity<i64, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for i128 {
    type Output = Quantity<i128, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for isize {
    type Output = Quantity<isize, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for u8 {
    type Output = Quantity<u8, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for u16 {
    type Output = Quantity<u16, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for u32 {
    type Output = Quantity<u32, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for u64 {
    type Output = Quantity<u64, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for u128 {
    type Output = Quantity<u128, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for usize {
    type Output = Quantity<usize, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for f32 {
    type Output = Quantity<f32, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
impl Mul<UnitNanosievertsMul> for f64 {
    type Output = Quantity<f64, UnitNanosieverts>;
    fn mul(self, _: UnitNanosievertsMul) -> Self::Output {
        Quantity::new(self, UnitNanosieverts)
    }
}
pub struct UnitPicosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosieverts {
    #[inline]
    fn clone(&self) -> UnitPicosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosieverts {
    #[inline]
    fn eq(&self, other: &UnitPicosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicosieverts {
    fn default() -> Self {
        UnitPicosieverts
    }
}
impl Add<UnitPicosieverts> for UnitPicosieverts {
    type Output = UnitPicosieverts;
    #[inline]
    fn add(self, _: UnitPicosieverts) -> Self::Output {
        UnitPicosieverts
    }
}
impl AddAssign<UnitPicosieverts> for UnitPicosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitPicosieverts) {}
}
impl Sub<UnitPicosieverts> for UnitPicosieverts {
    type Output = UnitPicosieverts;
    #[inline]
    fn sub(self, _: UnitPicosieverts) -> Self::Output {
        UnitPicosieverts
    }
}
impl SubAssign<UnitPicosieverts> for UnitPicosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicosieverts) {}
}
pub struct UnitPicosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicosievertsMul {
    #[inline]
    fn clone(&self) -> UnitPicosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitPicosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicosievertsMul> for i8 {
    type Output = Quantity<i8, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for i16 {
    type Output = Quantity<i16, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for i32 {
    type Output = Quantity<i32, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for i64 {
    type Output = Quantity<i64, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for i128 {
    type Output = Quantity<i128, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for isize {
    type Output = Quantity<isize, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for u8 {
    type Output = Quantity<u8, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for u16 {
    type Output = Quantity<u16, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for u32 {
    type Output = Quantity<u32, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for u64 {
    type Output = Quantity<u64, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for u128 {
    type Output = Quantity<u128, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for usize {
    type Output = Quantity<usize, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for f32 {
    type Output = Quantity<f32, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
impl Mul<UnitPicosievertsMul> for f64 {
    type Output = Quantity<f64, UnitPicosieverts>;
    fn mul(self, _: UnitPicosievertsMul) -> Self::Output {
        Quantity::new(self, UnitPicosieverts)
    }
}
pub struct UnitFemtosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosieverts {
    #[inline]
    fn clone(&self) -> UnitFemtosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosieverts {
    #[inline]
    fn eq(&self, other: &UnitFemtosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtosieverts {
    fn default() -> Self {
        UnitFemtosieverts
    }
}
impl Add<UnitFemtosieverts> for UnitFemtosieverts {
    type Output = UnitFemtosieverts;
    #[inline]
    fn add(self, _: UnitFemtosieverts) -> Self::Output {
        UnitFemtosieverts
    }
}
impl AddAssign<UnitFemtosieverts> for UnitFemtosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtosieverts) {}
}
impl Sub<UnitFemtosieverts> for UnitFemtosieverts {
    type Output = UnitFemtosieverts;
    #[inline]
    fn sub(self, _: UnitFemtosieverts) -> Self::Output {
        UnitFemtosieverts
    }
}
impl SubAssign<UnitFemtosieverts> for UnitFemtosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtosieverts) {}
}
pub struct UnitFemtosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtosievertsMul {
    #[inline]
    fn clone(&self) -> UnitFemtosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtosievertsMul> for i8 {
    type Output = Quantity<i8, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for i16 {
    type Output = Quantity<i16, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for i32 {
    type Output = Quantity<i32, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for i64 {
    type Output = Quantity<i64, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for i128 {
    type Output = Quantity<i128, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for isize {
    type Output = Quantity<isize, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for u8 {
    type Output = Quantity<u8, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for u16 {
    type Output = Quantity<u16, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for u32 {
    type Output = Quantity<u32, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for u64 {
    type Output = Quantity<u64, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for u128 {
    type Output = Quantity<u128, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for usize {
    type Output = Quantity<usize, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for f32 {
    type Output = Quantity<f32, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
impl Mul<UnitFemtosievertsMul> for f64 {
    type Output = Quantity<f64, UnitFemtosieverts>;
    fn mul(self, _: UnitFemtosievertsMul) -> Self::Output {
        Quantity::new(self, UnitFemtosieverts)
    }
}
pub struct UnitAttosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosieverts {
    #[inline]
    fn clone(&self) -> UnitAttosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosieverts {
    #[inline]
    fn eq(&self, other: &UnitAttosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttosieverts {
    fn default() -> Self {
        UnitAttosieverts
    }
}
impl Add<UnitAttosieverts> for UnitAttosieverts {
    type Output = UnitAttosieverts;
    #[inline]
    fn add(self, _: UnitAttosieverts) -> Self::Output {
        UnitAttosieverts
    }
}
impl AddAssign<UnitAttosieverts> for UnitAttosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitAttosieverts) {}
}
impl Sub<UnitAttosieverts> for UnitAttosieverts {
    type Output = UnitAttosieverts;
    #[inline]
    fn sub(self, _: UnitAttosieverts) -> Self::Output {
        UnitAttosieverts
    }
}
impl SubAssign<UnitAttosieverts> for UnitAttosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttosieverts) {}
}
pub struct UnitAttosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttosievertsMul {
    #[inline]
    fn clone(&self) -> UnitAttosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitAttosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttosievertsMul> for i8 {
    type Output = Quantity<i8, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for i16 {
    type Output = Quantity<i16, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for i32 {
    type Output = Quantity<i32, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for i64 {
    type Output = Quantity<i64, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for i128 {
    type Output = Quantity<i128, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for isize {
    type Output = Quantity<isize, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for u8 {
    type Output = Quantity<u8, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for u16 {
    type Output = Quantity<u16, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for u32 {
    type Output = Quantity<u32, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for u64 {
    type Output = Quantity<u64, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for u128 {
    type Output = Quantity<u128, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for usize {
    type Output = Quantity<usize, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for f32 {
    type Output = Quantity<f32, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
impl Mul<UnitAttosievertsMul> for f64 {
    type Output = Quantity<f64, UnitAttosieverts>;
    fn mul(self, _: UnitAttosievertsMul) -> Self::Output {
        Quantity::new(self, UnitAttosieverts)
    }
}
pub struct UnitZeptosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosieverts {
    #[inline]
    fn clone(&self) -> UnitZeptosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosieverts {
    #[inline]
    fn eq(&self, other: &UnitZeptosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptosieverts {
    fn default() -> Self {
        UnitZeptosieverts
    }
}
impl Add<UnitZeptosieverts> for UnitZeptosieverts {
    type Output = UnitZeptosieverts;
    #[inline]
    fn add(self, _: UnitZeptosieverts) -> Self::Output {
        UnitZeptosieverts
    }
}
impl AddAssign<UnitZeptosieverts> for UnitZeptosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptosieverts) {}
}
impl Sub<UnitZeptosieverts> for UnitZeptosieverts {
    type Output = UnitZeptosieverts;
    #[inline]
    fn sub(self, _: UnitZeptosieverts) -> Self::Output {
        UnitZeptosieverts
    }
}
impl SubAssign<UnitZeptosieverts> for UnitZeptosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptosieverts) {}
}
pub struct UnitZeptosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptosievertsMul {
    #[inline]
    fn clone(&self) -> UnitZeptosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptosievertsMul> for i8 {
    type Output = Quantity<i8, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for i16 {
    type Output = Quantity<i16, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for i32 {
    type Output = Quantity<i32, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for i64 {
    type Output = Quantity<i64, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for i128 {
    type Output = Quantity<i128, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for isize {
    type Output = Quantity<isize, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for u8 {
    type Output = Quantity<u8, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for u16 {
    type Output = Quantity<u16, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for u32 {
    type Output = Quantity<u32, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for u64 {
    type Output = Quantity<u64, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for u128 {
    type Output = Quantity<u128, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for usize {
    type Output = Quantity<usize, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for f32 {
    type Output = Quantity<f32, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
impl Mul<UnitZeptosievertsMul> for f64 {
    type Output = Quantity<f64, UnitZeptosieverts>;
    fn mul(self, _: UnitZeptosievertsMul) -> Self::Output {
        Quantity::new(self, UnitZeptosieverts)
    }
}
pub struct UnitYoctosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosieverts {
    #[inline]
    fn clone(&self) -> UnitYoctosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosieverts {
    #[inline]
    fn eq(&self, other: &UnitYoctosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctosieverts {
    fn default() -> Self {
        UnitYoctosieverts
    }
}
impl Add<UnitYoctosieverts> for UnitYoctosieverts {
    type Output = UnitYoctosieverts;
    #[inline]
    fn add(self, _: UnitYoctosieverts) -> Self::Output {
        UnitYoctosieverts
    }
}
impl AddAssign<UnitYoctosieverts> for UnitYoctosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctosieverts) {}
}
impl Sub<UnitYoctosieverts> for UnitYoctosieverts {
    type Output = UnitYoctosieverts;
    #[inline]
    fn sub(self, _: UnitYoctosieverts) -> Self::Output {
        UnitYoctosieverts
    }
}
impl SubAssign<UnitYoctosieverts> for UnitYoctosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctosieverts) {}
}
pub struct UnitYoctosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctosievertsMul {
    #[inline]
    fn clone(&self) -> UnitYoctosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctosievertsMul> for i8 {
    type Output = Quantity<i8, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for i16 {
    type Output = Quantity<i16, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for i32 {
    type Output = Quantity<i32, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for i64 {
    type Output = Quantity<i64, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for i128 {
    type Output = Quantity<i128, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for isize {
    type Output = Quantity<isize, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for u8 {
    type Output = Quantity<u8, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for u16 {
    type Output = Quantity<u16, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for u32 {
    type Output = Quantity<u32, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for u64 {
    type Output = Quantity<u64, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for u128 {
    type Output = Quantity<u128, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for usize {
    type Output = Quantity<usize, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for f32 {
    type Output = Quantity<f32, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
impl Mul<UnitYoctosievertsMul> for f64 {
    type Output = Quantity<f64, UnitYoctosieverts>;
    fn mul(self, _: UnitYoctosievertsMul) -> Self::Output {
        Quantity::new(self, UnitYoctosieverts)
    }
}
pub struct UnitRontosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosieverts {
    #[inline]
    fn clone(&self) -> UnitRontosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosieverts {
    #[inline]
    fn eq(&self, other: &UnitRontosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontosieverts {
    fn default() -> Self {
        UnitRontosieverts
    }
}
impl Add<UnitRontosieverts> for UnitRontosieverts {
    type Output = UnitRontosieverts;
    #[inline]
    fn add(self, _: UnitRontosieverts) -> Self::Output {
        UnitRontosieverts
    }
}
impl AddAssign<UnitRontosieverts> for UnitRontosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitRontosieverts) {}
}
impl Sub<UnitRontosieverts> for UnitRontosieverts {
    type Output = UnitRontosieverts;
    #[inline]
    fn sub(self, _: UnitRontosieverts) -> Self::Output {
        UnitRontosieverts
    }
}
impl SubAssign<UnitRontosieverts> for UnitRontosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontosieverts) {}
}
pub struct UnitRontosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontosievertsMul {
    #[inline]
    fn clone(&self) -> UnitRontosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitRontosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontosievertsMul> for i8 {
    type Output = Quantity<i8, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for i16 {
    type Output = Quantity<i16, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for i32 {
    type Output = Quantity<i32, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for i64 {
    type Output = Quantity<i64, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for i128 {
    type Output = Quantity<i128, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for isize {
    type Output = Quantity<isize, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for u8 {
    type Output = Quantity<u8, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for u16 {
    type Output = Quantity<u16, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for u32 {
    type Output = Quantity<u32, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for u64 {
    type Output = Quantity<u64, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for u128 {
    type Output = Quantity<u128, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for usize {
    type Output = Quantity<usize, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for f32 {
    type Output = Quantity<f32, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
impl Mul<UnitRontosievertsMul> for f64 {
    type Output = Quantity<f64, UnitRontosieverts>;
    fn mul(self, _: UnitRontosievertsMul) -> Self::Output {
        Quantity::new(self, UnitRontosieverts)
    }
}
pub struct UnitQuectosieverts;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosieverts {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosieverts")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosieverts {
    #[inline]
    fn clone(&self) -> UnitQuectosieverts {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosieverts {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosieverts {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosieverts {
    #[inline]
    fn eq(&self, other: &UnitQuectosieverts) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosieverts {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectosieverts {
    fn default() -> Self {
        UnitQuectosieverts
    }
}
impl Add<UnitQuectosieverts> for UnitQuectosieverts {
    type Output = UnitQuectosieverts;
    #[inline]
    fn add(self, _: UnitQuectosieverts) -> Self::Output {
        UnitQuectosieverts
    }
}
impl AddAssign<UnitQuectosieverts> for UnitQuectosieverts {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectosieverts) {}
}
impl Sub<UnitQuectosieverts> for UnitQuectosieverts {
    type Output = UnitQuectosieverts;
    #[inline]
    fn sub(self, _: UnitQuectosieverts) -> Self::Output {
        UnitQuectosieverts
    }
}
impl SubAssign<UnitQuectosieverts> for UnitQuectosieverts {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectosieverts) {}
}
pub struct UnitQuectosievertsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectosievertsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectosievertsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectosievertsMul {
    #[inline]
    fn clone(&self) -> UnitQuectosievertsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectosievertsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectosievertsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectosievertsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectosievertsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectosievertsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectosievertsMul> for i8 {
    type Output = Quantity<i8, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for i16 {
    type Output = Quantity<i16, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for i32 {
    type Output = Quantity<i32, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for i64 {
    type Output = Quantity<i64, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for i128 {
    type Output = Quantity<i128, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for isize {
    type Output = Quantity<isize, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for u8 {
    type Output = Quantity<u8, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for u16 {
    type Output = Quantity<u16, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for u32 {
    type Output = Quantity<u32, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for u64 {
    type Output = Quantity<u64, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for u128 {
    type Output = Quantity<u128, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for usize {
    type Output = Quantity<usize, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for f32 {
    type Output = Quantity<f32, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
impl Mul<UnitQuectosievertsMul> for f64 {
    type Output = Quantity<f64, UnitQuectosieverts>;
    fn mul(self, _: UnitQuectosievertsMul) -> Self::Output {
        Quantity::new(self, UnitQuectosieverts)
    }
}
pub type Sieverts<T> = Quantity<T, UnitSieverts>;
#[allow(non_upper_case_globals)]
pub static Sieverts: UnitSievertsMul = UnitSievertsMul;
pub type Quettasieverts<T> = Quantity<T, UnitQuettasieverts>;
#[allow(non_upper_case_globals)]
pub static Quettasieverts: UnitQuettasievertsMul = UnitQuettasievertsMul;
pub type Ronnasieverts<T> = Quantity<T, UnitRonnasieverts>;
#[allow(non_upper_case_globals)]
pub static Ronnasieverts: UnitRonnasievertsMul = UnitRonnasievertsMul;
pub type Yottasieverts<T> = Quantity<T, UnitYottasieverts>;
#[allow(non_upper_case_globals)]
pub static Yottasieverts: UnitYottasievertsMul = UnitYottasievertsMul;
pub type Zettasieverts<T> = Quantity<T, UnitZettasieverts>;
#[allow(non_upper_case_globals)]
pub static Zettasieverts: UnitZettasievertsMul = UnitZettasievertsMul;
pub type Exasieverts<T> = Quantity<T, UnitExasieverts>;
#[allow(non_upper_case_globals)]
pub static Exasieverts: UnitExasievertsMul = UnitExasievertsMul;
pub type Petasieverts<T> = Quantity<T, UnitPetasieverts>;
#[allow(non_upper_case_globals)]
pub static Petasieverts: UnitPetasievertsMul = UnitPetasievertsMul;
pub type Terasieverts<T> = Quantity<T, UnitTerasieverts>;
#[allow(non_upper_case_globals)]
pub static Terasieverts: UnitTerasievertsMul = UnitTerasievertsMul;
pub type Gigasieverts<T> = Quantity<T, UnitGigasieverts>;
#[allow(non_upper_case_globals)]
pub static Gigasieverts: UnitGigasievertsMul = UnitGigasievertsMul;
pub type Megasieverts<T> = Quantity<T, UnitMegasieverts>;
#[allow(non_upper_case_globals)]
pub static Megasieverts: UnitMegasievertsMul = UnitMegasievertsMul;
pub type Kilosieverts<T> = Quantity<T, UnitKilosieverts>;
#[allow(non_upper_case_globals)]
pub static Kilosieverts: UnitKilosievertsMul = UnitKilosievertsMul;
pub type Hectosieverts<T> = Quantity<T, UnitHectosieverts>;
#[allow(non_upper_case_globals)]
pub static Hectosieverts: UnitHectosievertsMul = UnitHectosievertsMul;
pub type Decasieverts<T> = Quantity<T, UnitDecasieverts>;
#[allow(non_upper_case_globals)]
pub static Decasieverts: UnitDecasievertsMul = UnitDecasievertsMul;
pub type Decisieverts<T> = Quantity<T, UnitDecisieverts>;
#[allow(non_upper_case_globals)]
pub static Decisieverts: UnitDecisievertsMul = UnitDecisievertsMul;
pub type Centisieverts<T> = Quantity<T, UnitCentisieverts>;
#[allow(non_upper_case_globals)]
pub static Centisieverts: UnitCentisievertsMul = UnitCentisievertsMul;
pub type Millisieverts<T> = Quantity<T, UnitMillisieverts>;
#[allow(non_upper_case_globals)]
pub static Millisieverts: UnitMillisievertsMul = UnitMillisievertsMul;
pub type Microsieverts<T> = Quantity<T, UnitMicrosieverts>;
#[allow(non_upper_case_globals)]
pub static Microsieverts: UnitMicrosievertsMul = UnitMicrosievertsMul;
pub type Nanosieverts<T> = Quantity<T, UnitNanosieverts>;
#[allow(non_upper_case_globals)]
pub static Nanosieverts: UnitNanosievertsMul = UnitNanosievertsMul;
pub type Picosieverts<T> = Quantity<T, UnitPicosieverts>;
#[allow(non_upper_case_globals)]
pub static Picosieverts: UnitPicosievertsMul = UnitPicosievertsMul;
pub type Femtosieverts<T> = Quantity<T, UnitFemtosieverts>;
#[allow(non_upper_case_globals)]
pub static Femtosieverts: UnitFemtosievertsMul = UnitFemtosievertsMul;
pub type Attosieverts<T> = Quantity<T, UnitAttosieverts>;
#[allow(non_upper_case_globals)]
pub static Attosieverts: UnitAttosievertsMul = UnitAttosievertsMul;
pub type Zeptosieverts<T> = Quantity<T, UnitZeptosieverts>;
#[allow(non_upper_case_globals)]
pub static Zeptosieverts: UnitZeptosievertsMul = UnitZeptosievertsMul;
pub type Yoctosieverts<T> = Quantity<T, UnitYoctosieverts>;
#[allow(non_upper_case_globals)]
pub static Yoctosieverts: UnitYoctosievertsMul = UnitYoctosievertsMul;
pub type Rontosieverts<T> = Quantity<T, UnitRontosieverts>;
#[allow(non_upper_case_globals)]
pub static Rontosieverts: UnitRontosievertsMul = UnitRontosievertsMul;
pub type Quectosieverts<T> = Quantity<T, UnitQuectosieverts>;
#[allow(non_upper_case_globals)]
pub static Quectosieverts: UnitQuectosievertsMul = UnitQuectosievertsMul;
pub struct UnitKatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKatals {
    #[inline]
    fn clone(&self) -> UnitKatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKatals {
    #[inline]
    fn eq(&self, other: &UnitKatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKatals {
    fn default() -> Self {
        UnitKatals
    }
}
impl Add<UnitKatals> for UnitKatals {
    type Output = UnitKatals;
    #[inline]
    fn add(self, _: UnitKatals) -> Self::Output {
        UnitKatals
    }
}
impl AddAssign<UnitKatals> for UnitKatals {
    #[inline]
    fn add_assign(&mut self, _: UnitKatals) {}
}
impl Sub<UnitKatals> for UnitKatals {
    type Output = UnitKatals;
    #[inline]
    fn sub(self, _: UnitKatals) -> Self::Output {
        UnitKatals
    }
}
impl SubAssign<UnitKatals> for UnitKatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitKatals) {}
}
pub struct UnitKatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKatalsMul {
    #[inline]
    fn clone(&self) -> UnitKatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKatalsMul {
    #[inline]
    fn eq(&self, other: &UnitKatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKatalsMul> for i8 {
    type Output = Quantity<i8, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for i16 {
    type Output = Quantity<i16, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for i32 {
    type Output = Quantity<i32, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for i64 {
    type Output = Quantity<i64, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for i128 {
    type Output = Quantity<i128, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for isize {
    type Output = Quantity<isize, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for u8 {
    type Output = Quantity<u8, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for u16 {
    type Output = Quantity<u16, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for u32 {
    type Output = Quantity<u32, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for u64 {
    type Output = Quantity<u64, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for u128 {
    type Output = Quantity<u128, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for usize {
    type Output = Quantity<usize, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for f32 {
    type Output = Quantity<f32, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
impl Mul<UnitKatalsMul> for f64 {
    type Output = Quantity<f64, UnitKatals>;
    fn mul(self, _: UnitKatalsMul) -> Self::Output {
        Quantity::new(self, UnitKatals)
    }
}
pub struct UnitQuettakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakatals {
    #[inline]
    fn clone(&self) -> UnitQuettakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakatals {
    #[inline]
    fn eq(&self, other: &UnitQuettakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettakatals {
    fn default() -> Self {
        UnitQuettakatals
    }
}
impl Add<UnitQuettakatals> for UnitQuettakatals {
    type Output = UnitQuettakatals;
    #[inline]
    fn add(self, _: UnitQuettakatals) -> Self::Output {
        UnitQuettakatals
    }
}
impl AddAssign<UnitQuettakatals> for UnitQuettakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettakatals) {}
}
impl Sub<UnitQuettakatals> for UnitQuettakatals {
    type Output = UnitQuettakatals;
    #[inline]
    fn sub(self, _: UnitQuettakatals) -> Self::Output {
        UnitQuettakatals
    }
}
impl SubAssign<UnitQuettakatals> for UnitQuettakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettakatals) {}
}
pub struct UnitQuettakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakatalsMul {
    #[inline]
    fn clone(&self) -> UnitQuettakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettakatalsMul> for i8 {
    type Output = Quantity<i8, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for i16 {
    type Output = Quantity<i16, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for i32 {
    type Output = Quantity<i32, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for i64 {
    type Output = Quantity<i64, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for i128 {
    type Output = Quantity<i128, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for isize {
    type Output = Quantity<isize, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for u8 {
    type Output = Quantity<u8, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for u16 {
    type Output = Quantity<u16, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for u32 {
    type Output = Quantity<u32, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for u64 {
    type Output = Quantity<u64, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for u128 {
    type Output = Quantity<u128, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for usize {
    type Output = Quantity<usize, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for f32 {
    type Output = Quantity<f32, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
impl Mul<UnitQuettakatalsMul> for f64 {
    type Output = Quantity<f64, UnitQuettakatals>;
    fn mul(self, _: UnitQuettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettakatals)
    }
}
pub struct UnitRonnakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakatals {
    #[inline]
    fn clone(&self) -> UnitRonnakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakatals {
    #[inline]
    fn eq(&self, other: &UnitRonnakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnakatals {
    fn default() -> Self {
        UnitRonnakatals
    }
}
impl Add<UnitRonnakatals> for UnitRonnakatals {
    type Output = UnitRonnakatals;
    #[inline]
    fn add(self, _: UnitRonnakatals) -> Self::Output {
        UnitRonnakatals
    }
}
impl AddAssign<UnitRonnakatals> for UnitRonnakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnakatals) {}
}
impl Sub<UnitRonnakatals> for UnitRonnakatals {
    type Output = UnitRonnakatals;
    #[inline]
    fn sub(self, _: UnitRonnakatals) -> Self::Output {
        UnitRonnakatals
    }
}
impl SubAssign<UnitRonnakatals> for UnitRonnakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnakatals) {}
}
pub struct UnitRonnakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakatalsMul {
    #[inline]
    fn clone(&self) -> UnitRonnakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnakatalsMul> for i8 {
    type Output = Quantity<i8, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for i16 {
    type Output = Quantity<i16, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for i32 {
    type Output = Quantity<i32, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for i64 {
    type Output = Quantity<i64, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for i128 {
    type Output = Quantity<i128, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for isize {
    type Output = Quantity<isize, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for u8 {
    type Output = Quantity<u8, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for u16 {
    type Output = Quantity<u16, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for u32 {
    type Output = Quantity<u32, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for u64 {
    type Output = Quantity<u64, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for u128 {
    type Output = Quantity<u128, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for usize {
    type Output = Quantity<usize, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for f32 {
    type Output = Quantity<f32, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
impl Mul<UnitRonnakatalsMul> for f64 {
    type Output = Quantity<f64, UnitRonnakatals>;
    fn mul(self, _: UnitRonnakatalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnakatals)
    }
}
pub struct UnitYottakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakatals {
    #[inline]
    fn clone(&self) -> UnitYottakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakatals {
    #[inline]
    fn eq(&self, other: &UnitYottakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottakatals {
    fn default() -> Self {
        UnitYottakatals
    }
}
impl Add<UnitYottakatals> for UnitYottakatals {
    type Output = UnitYottakatals;
    #[inline]
    fn add(self, _: UnitYottakatals) -> Self::Output {
        UnitYottakatals
    }
}
impl AddAssign<UnitYottakatals> for UnitYottakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitYottakatals) {}
}
impl Sub<UnitYottakatals> for UnitYottakatals {
    type Output = UnitYottakatals;
    #[inline]
    fn sub(self, _: UnitYottakatals) -> Self::Output {
        UnitYottakatals
    }
}
impl SubAssign<UnitYottakatals> for UnitYottakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottakatals) {}
}
pub struct UnitYottakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakatalsMul {
    #[inline]
    fn clone(&self) -> UnitYottakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitYottakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottakatalsMul> for i8 {
    type Output = Quantity<i8, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for i16 {
    type Output = Quantity<i16, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for i32 {
    type Output = Quantity<i32, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for i64 {
    type Output = Quantity<i64, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for i128 {
    type Output = Quantity<i128, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for isize {
    type Output = Quantity<isize, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for u8 {
    type Output = Quantity<u8, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for u16 {
    type Output = Quantity<u16, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for u32 {
    type Output = Quantity<u32, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for u64 {
    type Output = Quantity<u64, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for u128 {
    type Output = Quantity<u128, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for usize {
    type Output = Quantity<usize, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for f32 {
    type Output = Quantity<f32, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
impl Mul<UnitYottakatalsMul> for f64 {
    type Output = Quantity<f64, UnitYottakatals>;
    fn mul(self, _: UnitYottakatalsMul) -> Self::Output {
        Quantity::new(self, UnitYottakatals)
    }
}
pub struct UnitZettakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakatals {
    #[inline]
    fn clone(&self) -> UnitZettakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakatals {
    #[inline]
    fn eq(&self, other: &UnitZettakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettakatals {
    fn default() -> Self {
        UnitZettakatals
    }
}
impl Add<UnitZettakatals> for UnitZettakatals {
    type Output = UnitZettakatals;
    #[inline]
    fn add(self, _: UnitZettakatals) -> Self::Output {
        UnitZettakatals
    }
}
impl AddAssign<UnitZettakatals> for UnitZettakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitZettakatals) {}
}
impl Sub<UnitZettakatals> for UnitZettakatals {
    type Output = UnitZettakatals;
    #[inline]
    fn sub(self, _: UnitZettakatals) -> Self::Output {
        UnitZettakatals
    }
}
impl SubAssign<UnitZettakatals> for UnitZettakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettakatals) {}
}
pub struct UnitZettakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakatalsMul {
    #[inline]
    fn clone(&self) -> UnitZettakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitZettakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettakatalsMul> for i8 {
    type Output = Quantity<i8, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for i16 {
    type Output = Quantity<i16, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for i32 {
    type Output = Quantity<i32, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for i64 {
    type Output = Quantity<i64, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for i128 {
    type Output = Quantity<i128, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for isize {
    type Output = Quantity<isize, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for u8 {
    type Output = Quantity<u8, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for u16 {
    type Output = Quantity<u16, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for u32 {
    type Output = Quantity<u32, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for u64 {
    type Output = Quantity<u64, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for u128 {
    type Output = Quantity<u128, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for usize {
    type Output = Quantity<usize, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for f32 {
    type Output = Quantity<f32, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
impl Mul<UnitZettakatalsMul> for f64 {
    type Output = Quantity<f64, UnitZettakatals>;
    fn mul(self, _: UnitZettakatalsMul) -> Self::Output {
        Quantity::new(self, UnitZettakatals)
    }
}
pub struct UnitExakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakatals {
    #[inline]
    fn clone(&self) -> UnitExakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakatals {
    #[inline]
    fn eq(&self, other: &UnitExakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExakatals {
    fn default() -> Self {
        UnitExakatals
    }
}
impl Add<UnitExakatals> for UnitExakatals {
    type Output = UnitExakatals;
    #[inline]
    fn add(self, _: UnitExakatals) -> Self::Output {
        UnitExakatals
    }
}
impl AddAssign<UnitExakatals> for UnitExakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitExakatals) {}
}
impl Sub<UnitExakatals> for UnitExakatals {
    type Output = UnitExakatals;
    #[inline]
    fn sub(self, _: UnitExakatals) -> Self::Output {
        UnitExakatals
    }
}
impl SubAssign<UnitExakatals> for UnitExakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitExakatals) {}
}
pub struct UnitExakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakatalsMul {
    #[inline]
    fn clone(&self) -> UnitExakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitExakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExakatalsMul> for i8 {
    type Output = Quantity<i8, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for i16 {
    type Output = Quantity<i16, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for i32 {
    type Output = Quantity<i32, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for i64 {
    type Output = Quantity<i64, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for i128 {
    type Output = Quantity<i128, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for isize {
    type Output = Quantity<isize, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for u8 {
    type Output = Quantity<u8, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for u16 {
    type Output = Quantity<u16, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for u32 {
    type Output = Quantity<u32, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for u64 {
    type Output = Quantity<u64, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for u128 {
    type Output = Quantity<u128, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for usize {
    type Output = Quantity<usize, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for f32 {
    type Output = Quantity<f32, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
impl Mul<UnitExakatalsMul> for f64 {
    type Output = Quantity<f64, UnitExakatals>;
    fn mul(self, _: UnitExakatalsMul) -> Self::Output {
        Quantity::new(self, UnitExakatals)
    }
}
pub struct UnitPetakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakatals {
    #[inline]
    fn clone(&self) -> UnitPetakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakatals {
    #[inline]
    fn eq(&self, other: &UnitPetakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetakatals {
    fn default() -> Self {
        UnitPetakatals
    }
}
impl Add<UnitPetakatals> for UnitPetakatals {
    type Output = UnitPetakatals;
    #[inline]
    fn add(self, _: UnitPetakatals) -> Self::Output {
        UnitPetakatals
    }
}
impl AddAssign<UnitPetakatals> for UnitPetakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitPetakatals) {}
}
impl Sub<UnitPetakatals> for UnitPetakatals {
    type Output = UnitPetakatals;
    #[inline]
    fn sub(self, _: UnitPetakatals) -> Self::Output {
        UnitPetakatals
    }
}
impl SubAssign<UnitPetakatals> for UnitPetakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetakatals) {}
}
pub struct UnitPetakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakatalsMul {
    #[inline]
    fn clone(&self) -> UnitPetakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitPetakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetakatalsMul> for i8 {
    type Output = Quantity<i8, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for i16 {
    type Output = Quantity<i16, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for i32 {
    type Output = Quantity<i32, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for i64 {
    type Output = Quantity<i64, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for i128 {
    type Output = Quantity<i128, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for isize {
    type Output = Quantity<isize, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for u8 {
    type Output = Quantity<u8, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for u16 {
    type Output = Quantity<u16, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for u32 {
    type Output = Quantity<u32, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for u64 {
    type Output = Quantity<u64, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for u128 {
    type Output = Quantity<u128, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for usize {
    type Output = Quantity<usize, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for f32 {
    type Output = Quantity<f32, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
impl Mul<UnitPetakatalsMul> for f64 {
    type Output = Quantity<f64, UnitPetakatals>;
    fn mul(self, _: UnitPetakatalsMul) -> Self::Output {
        Quantity::new(self, UnitPetakatals)
    }
}
pub struct UnitTerakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakatals {
    #[inline]
    fn clone(&self) -> UnitTerakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakatals {
    #[inline]
    fn eq(&self, other: &UnitTerakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerakatals {
    fn default() -> Self {
        UnitTerakatals
    }
}
impl Add<UnitTerakatals> for UnitTerakatals {
    type Output = UnitTerakatals;
    #[inline]
    fn add(self, _: UnitTerakatals) -> Self::Output {
        UnitTerakatals
    }
}
impl AddAssign<UnitTerakatals> for UnitTerakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitTerakatals) {}
}
impl Sub<UnitTerakatals> for UnitTerakatals {
    type Output = UnitTerakatals;
    #[inline]
    fn sub(self, _: UnitTerakatals) -> Self::Output {
        UnitTerakatals
    }
}
impl SubAssign<UnitTerakatals> for UnitTerakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerakatals) {}
}
pub struct UnitTerakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakatalsMul {
    #[inline]
    fn clone(&self) -> UnitTerakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitTerakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerakatalsMul> for i8 {
    type Output = Quantity<i8, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for i16 {
    type Output = Quantity<i16, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for i32 {
    type Output = Quantity<i32, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for i64 {
    type Output = Quantity<i64, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for i128 {
    type Output = Quantity<i128, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for isize {
    type Output = Quantity<isize, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for u8 {
    type Output = Quantity<u8, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for u16 {
    type Output = Quantity<u16, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for u32 {
    type Output = Quantity<u32, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for u64 {
    type Output = Quantity<u64, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for u128 {
    type Output = Quantity<u128, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for usize {
    type Output = Quantity<usize, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for f32 {
    type Output = Quantity<f32, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
impl Mul<UnitTerakatalsMul> for f64 {
    type Output = Quantity<f64, UnitTerakatals>;
    fn mul(self, _: UnitTerakatalsMul) -> Self::Output {
        Quantity::new(self, UnitTerakatals)
    }
}
pub struct UnitGigakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakatals {
    #[inline]
    fn clone(&self) -> UnitGigakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakatals {
    #[inline]
    fn eq(&self, other: &UnitGigakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigakatals {
    fn default() -> Self {
        UnitGigakatals
    }
}
impl Add<UnitGigakatals> for UnitGigakatals {
    type Output = UnitGigakatals;
    #[inline]
    fn add(self, _: UnitGigakatals) -> Self::Output {
        UnitGigakatals
    }
}
impl AddAssign<UnitGigakatals> for UnitGigakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitGigakatals) {}
}
impl Sub<UnitGigakatals> for UnitGigakatals {
    type Output = UnitGigakatals;
    #[inline]
    fn sub(self, _: UnitGigakatals) -> Self::Output {
        UnitGigakatals
    }
}
impl SubAssign<UnitGigakatals> for UnitGigakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigakatals) {}
}
pub struct UnitGigakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakatalsMul {
    #[inline]
    fn clone(&self) -> UnitGigakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitGigakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigakatalsMul> for i8 {
    type Output = Quantity<i8, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for i16 {
    type Output = Quantity<i16, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for i32 {
    type Output = Quantity<i32, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for i64 {
    type Output = Quantity<i64, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for i128 {
    type Output = Quantity<i128, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for isize {
    type Output = Quantity<isize, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for u8 {
    type Output = Quantity<u8, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for u16 {
    type Output = Quantity<u16, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for u32 {
    type Output = Quantity<u32, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for u64 {
    type Output = Quantity<u64, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for u128 {
    type Output = Quantity<u128, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for usize {
    type Output = Quantity<usize, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for f32 {
    type Output = Quantity<f32, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
impl Mul<UnitGigakatalsMul> for f64 {
    type Output = Quantity<f64, UnitGigakatals>;
    fn mul(self, _: UnitGigakatalsMul) -> Self::Output {
        Quantity::new(self, UnitGigakatals)
    }
}
pub struct UnitMegakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakatals {
    #[inline]
    fn clone(&self) -> UnitMegakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakatals {
    #[inline]
    fn eq(&self, other: &UnitMegakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegakatals {
    fn default() -> Self {
        UnitMegakatals
    }
}
impl Add<UnitMegakatals> for UnitMegakatals {
    type Output = UnitMegakatals;
    #[inline]
    fn add(self, _: UnitMegakatals) -> Self::Output {
        UnitMegakatals
    }
}
impl AddAssign<UnitMegakatals> for UnitMegakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitMegakatals) {}
}
impl Sub<UnitMegakatals> for UnitMegakatals {
    type Output = UnitMegakatals;
    #[inline]
    fn sub(self, _: UnitMegakatals) -> Self::Output {
        UnitMegakatals
    }
}
impl SubAssign<UnitMegakatals> for UnitMegakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegakatals) {}
}
pub struct UnitMegakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakatalsMul {
    #[inline]
    fn clone(&self) -> UnitMegakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitMegakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegakatalsMul> for i8 {
    type Output = Quantity<i8, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for i16 {
    type Output = Quantity<i16, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for i32 {
    type Output = Quantity<i32, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for i64 {
    type Output = Quantity<i64, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for i128 {
    type Output = Quantity<i128, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for isize {
    type Output = Quantity<isize, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for u8 {
    type Output = Quantity<u8, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for u16 {
    type Output = Quantity<u16, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for u32 {
    type Output = Quantity<u32, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for u64 {
    type Output = Quantity<u64, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for u128 {
    type Output = Quantity<u128, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for usize {
    type Output = Quantity<usize, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for f32 {
    type Output = Quantity<f32, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
impl Mul<UnitMegakatalsMul> for f64 {
    type Output = Quantity<f64, UnitMegakatals>;
    fn mul(self, _: UnitMegakatalsMul) -> Self::Output {
        Quantity::new(self, UnitMegakatals)
    }
}
pub struct UnitKilokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokatals {
    #[inline]
    fn clone(&self) -> UnitKilokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokatals {
    #[inline]
    fn eq(&self, other: &UnitKilokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilokatals {
    fn default() -> Self {
        UnitKilokatals
    }
}
impl Add<UnitKilokatals> for UnitKilokatals {
    type Output = UnitKilokatals;
    #[inline]
    fn add(self, _: UnitKilokatals) -> Self::Output {
        UnitKilokatals
    }
}
impl AddAssign<UnitKilokatals> for UnitKilokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitKilokatals) {}
}
impl Sub<UnitKilokatals> for UnitKilokatals {
    type Output = UnitKilokatals;
    #[inline]
    fn sub(self, _: UnitKilokatals) -> Self::Output {
        UnitKilokatals
    }
}
impl SubAssign<UnitKilokatals> for UnitKilokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilokatals) {}
}
pub struct UnitKilokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokatalsMul {
    #[inline]
    fn clone(&self) -> UnitKilokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitKilokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilokatalsMul> for i8 {
    type Output = Quantity<i8, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for i16 {
    type Output = Quantity<i16, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for i32 {
    type Output = Quantity<i32, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for i64 {
    type Output = Quantity<i64, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for i128 {
    type Output = Quantity<i128, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for isize {
    type Output = Quantity<isize, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for u8 {
    type Output = Quantity<u8, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for u16 {
    type Output = Quantity<u16, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for u32 {
    type Output = Quantity<u32, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for u64 {
    type Output = Quantity<u64, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for u128 {
    type Output = Quantity<u128, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for usize {
    type Output = Quantity<usize, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for f32 {
    type Output = Quantity<f32, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
impl Mul<UnitKilokatalsMul> for f64 {
    type Output = Quantity<f64, UnitKilokatals>;
    fn mul(self, _: UnitKilokatalsMul) -> Self::Output {
        Quantity::new(self, UnitKilokatals)
    }
}
pub struct UnitHectokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokatals {
    #[inline]
    fn clone(&self) -> UnitHectokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokatals {
    #[inline]
    fn eq(&self, other: &UnitHectokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectokatals {
    fn default() -> Self {
        UnitHectokatals
    }
}
impl Add<UnitHectokatals> for UnitHectokatals {
    type Output = UnitHectokatals;
    #[inline]
    fn add(self, _: UnitHectokatals) -> Self::Output {
        UnitHectokatals
    }
}
impl AddAssign<UnitHectokatals> for UnitHectokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitHectokatals) {}
}
impl Sub<UnitHectokatals> for UnitHectokatals {
    type Output = UnitHectokatals;
    #[inline]
    fn sub(self, _: UnitHectokatals) -> Self::Output {
        UnitHectokatals
    }
}
impl SubAssign<UnitHectokatals> for UnitHectokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectokatals) {}
}
pub struct UnitHectokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokatalsMul {
    #[inline]
    fn clone(&self) -> UnitHectokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitHectokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectokatalsMul> for i8 {
    type Output = Quantity<i8, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for i16 {
    type Output = Quantity<i16, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for i32 {
    type Output = Quantity<i32, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for i64 {
    type Output = Quantity<i64, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for i128 {
    type Output = Quantity<i128, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for isize {
    type Output = Quantity<isize, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for u8 {
    type Output = Quantity<u8, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for u16 {
    type Output = Quantity<u16, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for u32 {
    type Output = Quantity<u32, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for u64 {
    type Output = Quantity<u64, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for u128 {
    type Output = Quantity<u128, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for usize {
    type Output = Quantity<usize, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for f32 {
    type Output = Quantity<f32, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
impl Mul<UnitHectokatalsMul> for f64 {
    type Output = Quantity<f64, UnitHectokatals>;
    fn mul(self, _: UnitHectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitHectokatals)
    }
}
pub struct UnitDecakatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakatals {
    #[inline]
    fn clone(&self) -> UnitDecakatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakatals {
    #[inline]
    fn eq(&self, other: &UnitDecakatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecakatals {
    fn default() -> Self {
        UnitDecakatals
    }
}
impl Add<UnitDecakatals> for UnitDecakatals {
    type Output = UnitDecakatals;
    #[inline]
    fn add(self, _: UnitDecakatals) -> Self::Output {
        UnitDecakatals
    }
}
impl AddAssign<UnitDecakatals> for UnitDecakatals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecakatals) {}
}
impl Sub<UnitDecakatals> for UnitDecakatals {
    type Output = UnitDecakatals;
    #[inline]
    fn sub(self, _: UnitDecakatals) -> Self::Output {
        UnitDecakatals
    }
}
impl SubAssign<UnitDecakatals> for UnitDecakatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecakatals) {}
}
pub struct UnitDecakatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakatalsMul {
    #[inline]
    fn clone(&self) -> UnitDecakatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakatalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecakatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecakatalsMul> for i8 {
    type Output = Quantity<i8, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for i16 {
    type Output = Quantity<i16, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for i32 {
    type Output = Quantity<i32, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for i64 {
    type Output = Quantity<i64, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for i128 {
    type Output = Quantity<i128, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for isize {
    type Output = Quantity<isize, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for u8 {
    type Output = Quantity<u8, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for u16 {
    type Output = Quantity<u16, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for u32 {
    type Output = Quantity<u32, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for u64 {
    type Output = Quantity<u64, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for u128 {
    type Output = Quantity<u128, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for usize {
    type Output = Quantity<usize, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for f32 {
    type Output = Quantity<f32, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
impl Mul<UnitDecakatalsMul> for f64 {
    type Output = Quantity<f64, UnitDecakatals>;
    fn mul(self, _: UnitDecakatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecakatals)
    }
}
pub struct UnitDecikatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikatals {
    #[inline]
    fn clone(&self) -> UnitDecikatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikatals {
    #[inline]
    fn eq(&self, other: &UnitDecikatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecikatals {
    fn default() -> Self {
        UnitDecikatals
    }
}
impl Add<UnitDecikatals> for UnitDecikatals {
    type Output = UnitDecikatals;
    #[inline]
    fn add(self, _: UnitDecikatals) -> Self::Output {
        UnitDecikatals
    }
}
impl AddAssign<UnitDecikatals> for UnitDecikatals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecikatals) {}
}
impl Sub<UnitDecikatals> for UnitDecikatals {
    type Output = UnitDecikatals;
    #[inline]
    fn sub(self, _: UnitDecikatals) -> Self::Output {
        UnitDecikatals
    }
}
impl SubAssign<UnitDecikatals> for UnitDecikatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecikatals) {}
}
pub struct UnitDecikatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikatalsMul {
    #[inline]
    fn clone(&self) -> UnitDecikatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikatalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecikatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecikatalsMul> for i8 {
    type Output = Quantity<i8, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for i16 {
    type Output = Quantity<i16, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for i32 {
    type Output = Quantity<i32, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for i64 {
    type Output = Quantity<i64, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for i128 {
    type Output = Quantity<i128, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for isize {
    type Output = Quantity<isize, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for u8 {
    type Output = Quantity<u8, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for u16 {
    type Output = Quantity<u16, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for u32 {
    type Output = Quantity<u32, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for u64 {
    type Output = Quantity<u64, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for u128 {
    type Output = Quantity<u128, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for usize {
    type Output = Quantity<usize, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for f32 {
    type Output = Quantity<f32, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
impl Mul<UnitDecikatalsMul> for f64 {
    type Output = Quantity<f64, UnitDecikatals>;
    fn mul(self, _: UnitDecikatalsMul) -> Self::Output {
        Quantity::new(self, UnitDecikatals)
    }
}
pub struct UnitCentikatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikatals {
    #[inline]
    fn clone(&self) -> UnitCentikatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikatals {
    #[inline]
    fn eq(&self, other: &UnitCentikatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentikatals {
    fn default() -> Self {
        UnitCentikatals
    }
}
impl Add<UnitCentikatals> for UnitCentikatals {
    type Output = UnitCentikatals;
    #[inline]
    fn add(self, _: UnitCentikatals) -> Self::Output {
        UnitCentikatals
    }
}
impl AddAssign<UnitCentikatals> for UnitCentikatals {
    #[inline]
    fn add_assign(&mut self, _: UnitCentikatals) {}
}
impl Sub<UnitCentikatals> for UnitCentikatals {
    type Output = UnitCentikatals;
    #[inline]
    fn sub(self, _: UnitCentikatals) -> Self::Output {
        UnitCentikatals
    }
}
impl SubAssign<UnitCentikatals> for UnitCentikatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentikatals) {}
}
pub struct UnitCentikatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikatalsMul {
    #[inline]
    fn clone(&self) -> UnitCentikatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikatalsMul {
    #[inline]
    fn eq(&self, other: &UnitCentikatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentikatalsMul> for i8 {
    type Output = Quantity<i8, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for i16 {
    type Output = Quantity<i16, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for i32 {
    type Output = Quantity<i32, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for i64 {
    type Output = Quantity<i64, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for i128 {
    type Output = Quantity<i128, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for isize {
    type Output = Quantity<isize, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for u8 {
    type Output = Quantity<u8, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for u16 {
    type Output = Quantity<u16, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for u32 {
    type Output = Quantity<u32, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for u64 {
    type Output = Quantity<u64, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for u128 {
    type Output = Quantity<u128, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for usize {
    type Output = Quantity<usize, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for f32 {
    type Output = Quantity<f32, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
impl Mul<UnitCentikatalsMul> for f64 {
    type Output = Quantity<f64, UnitCentikatals>;
    fn mul(self, _: UnitCentikatalsMul) -> Self::Output {
        Quantity::new(self, UnitCentikatals)
    }
}
pub struct UnitMillikatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikatals {
    #[inline]
    fn clone(&self) -> UnitMillikatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikatals {
    #[inline]
    fn eq(&self, other: &UnitMillikatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillikatals {
    fn default() -> Self {
        UnitMillikatals
    }
}
impl Add<UnitMillikatals> for UnitMillikatals {
    type Output = UnitMillikatals;
    #[inline]
    fn add(self, _: UnitMillikatals) -> Self::Output {
        UnitMillikatals
    }
}
impl AddAssign<UnitMillikatals> for UnitMillikatals {
    #[inline]
    fn add_assign(&mut self, _: UnitMillikatals) {}
}
impl Sub<UnitMillikatals> for UnitMillikatals {
    type Output = UnitMillikatals;
    #[inline]
    fn sub(self, _: UnitMillikatals) -> Self::Output {
        UnitMillikatals
    }
}
impl SubAssign<UnitMillikatals> for UnitMillikatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillikatals) {}
}
pub struct UnitMillikatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikatalsMul {
    #[inline]
    fn clone(&self) -> UnitMillikatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikatalsMul {
    #[inline]
    fn eq(&self, other: &UnitMillikatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillikatalsMul> for i8 {
    type Output = Quantity<i8, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for i16 {
    type Output = Quantity<i16, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for i32 {
    type Output = Quantity<i32, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for i64 {
    type Output = Quantity<i64, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for i128 {
    type Output = Quantity<i128, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for isize {
    type Output = Quantity<isize, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for u8 {
    type Output = Quantity<u8, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for u16 {
    type Output = Quantity<u16, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for u32 {
    type Output = Quantity<u32, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for u64 {
    type Output = Quantity<u64, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for u128 {
    type Output = Quantity<u128, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for usize {
    type Output = Quantity<usize, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for f32 {
    type Output = Quantity<f32, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
impl Mul<UnitMillikatalsMul> for f64 {
    type Output = Quantity<f64, UnitMillikatals>;
    fn mul(self, _: UnitMillikatalsMul) -> Self::Output {
        Quantity::new(self, UnitMillikatals)
    }
}
pub struct UnitMicrokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokatals {
    #[inline]
    fn clone(&self) -> UnitMicrokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokatals {
    #[inline]
    fn eq(&self, other: &UnitMicrokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrokatals {
    fn default() -> Self {
        UnitMicrokatals
    }
}
impl Add<UnitMicrokatals> for UnitMicrokatals {
    type Output = UnitMicrokatals;
    #[inline]
    fn add(self, _: UnitMicrokatals) -> Self::Output {
        UnitMicrokatals
    }
}
impl AddAssign<UnitMicrokatals> for UnitMicrokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrokatals) {}
}
impl Sub<UnitMicrokatals> for UnitMicrokatals {
    type Output = UnitMicrokatals;
    #[inline]
    fn sub(self, _: UnitMicrokatals) -> Self::Output {
        UnitMicrokatals
    }
}
impl SubAssign<UnitMicrokatals> for UnitMicrokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrokatals) {}
}
pub struct UnitMicrokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokatalsMul {
    #[inline]
    fn clone(&self) -> UnitMicrokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrokatalsMul> for i8 {
    type Output = Quantity<i8, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for i16 {
    type Output = Quantity<i16, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for i32 {
    type Output = Quantity<i32, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for i64 {
    type Output = Quantity<i64, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for i128 {
    type Output = Quantity<i128, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for isize {
    type Output = Quantity<isize, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for u8 {
    type Output = Quantity<u8, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for u16 {
    type Output = Quantity<u16, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for u32 {
    type Output = Quantity<u32, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for u64 {
    type Output = Quantity<u64, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for u128 {
    type Output = Quantity<u128, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for usize {
    type Output = Quantity<usize, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for f32 {
    type Output = Quantity<f32, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
impl Mul<UnitMicrokatalsMul> for f64 {
    type Output = Quantity<f64, UnitMicrokatals>;
    fn mul(self, _: UnitMicrokatalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrokatals)
    }
}
pub struct UnitNanokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokatals {
    #[inline]
    fn clone(&self) -> UnitNanokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokatals {
    #[inline]
    fn eq(&self, other: &UnitNanokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanokatals {
    fn default() -> Self {
        UnitNanokatals
    }
}
impl Add<UnitNanokatals> for UnitNanokatals {
    type Output = UnitNanokatals;
    #[inline]
    fn add(self, _: UnitNanokatals) -> Self::Output {
        UnitNanokatals
    }
}
impl AddAssign<UnitNanokatals> for UnitNanokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitNanokatals) {}
}
impl Sub<UnitNanokatals> for UnitNanokatals {
    type Output = UnitNanokatals;
    #[inline]
    fn sub(self, _: UnitNanokatals) -> Self::Output {
        UnitNanokatals
    }
}
impl SubAssign<UnitNanokatals> for UnitNanokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanokatals) {}
}
pub struct UnitNanokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokatalsMul {
    #[inline]
    fn clone(&self) -> UnitNanokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitNanokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanokatalsMul> for i8 {
    type Output = Quantity<i8, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for i16 {
    type Output = Quantity<i16, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for i32 {
    type Output = Quantity<i32, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for i64 {
    type Output = Quantity<i64, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for i128 {
    type Output = Quantity<i128, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for isize {
    type Output = Quantity<isize, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for u8 {
    type Output = Quantity<u8, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for u16 {
    type Output = Quantity<u16, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for u32 {
    type Output = Quantity<u32, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for u64 {
    type Output = Quantity<u64, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for u128 {
    type Output = Quantity<u128, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for usize {
    type Output = Quantity<usize, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for f32 {
    type Output = Quantity<f32, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
impl Mul<UnitNanokatalsMul> for f64 {
    type Output = Quantity<f64, UnitNanokatals>;
    fn mul(self, _: UnitNanokatalsMul) -> Self::Output {
        Quantity::new(self, UnitNanokatals)
    }
}
pub struct UnitPicokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokatals {
    #[inline]
    fn clone(&self) -> UnitPicokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokatals {
    #[inline]
    fn eq(&self, other: &UnitPicokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicokatals {
    fn default() -> Self {
        UnitPicokatals
    }
}
impl Add<UnitPicokatals> for UnitPicokatals {
    type Output = UnitPicokatals;
    #[inline]
    fn add(self, _: UnitPicokatals) -> Self::Output {
        UnitPicokatals
    }
}
impl AddAssign<UnitPicokatals> for UnitPicokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitPicokatals) {}
}
impl Sub<UnitPicokatals> for UnitPicokatals {
    type Output = UnitPicokatals;
    #[inline]
    fn sub(self, _: UnitPicokatals) -> Self::Output {
        UnitPicokatals
    }
}
impl SubAssign<UnitPicokatals> for UnitPicokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicokatals) {}
}
pub struct UnitPicokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokatalsMul {
    #[inline]
    fn clone(&self) -> UnitPicokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitPicokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicokatalsMul> for i8 {
    type Output = Quantity<i8, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for i16 {
    type Output = Quantity<i16, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for i32 {
    type Output = Quantity<i32, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for i64 {
    type Output = Quantity<i64, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for i128 {
    type Output = Quantity<i128, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for isize {
    type Output = Quantity<isize, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for u8 {
    type Output = Quantity<u8, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for u16 {
    type Output = Quantity<u16, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for u32 {
    type Output = Quantity<u32, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for u64 {
    type Output = Quantity<u64, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for u128 {
    type Output = Quantity<u128, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for usize {
    type Output = Quantity<usize, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for f32 {
    type Output = Quantity<f32, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
impl Mul<UnitPicokatalsMul> for f64 {
    type Output = Quantity<f64, UnitPicokatals>;
    fn mul(self, _: UnitPicokatalsMul) -> Self::Output {
        Quantity::new(self, UnitPicokatals)
    }
}
pub struct UnitFemtokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokatals {
    #[inline]
    fn clone(&self) -> UnitFemtokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokatals {
    #[inline]
    fn eq(&self, other: &UnitFemtokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtokatals {
    fn default() -> Self {
        UnitFemtokatals
    }
}
impl Add<UnitFemtokatals> for UnitFemtokatals {
    type Output = UnitFemtokatals;
    #[inline]
    fn add(self, _: UnitFemtokatals) -> Self::Output {
        UnitFemtokatals
    }
}
impl AddAssign<UnitFemtokatals> for UnitFemtokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtokatals) {}
}
impl Sub<UnitFemtokatals> for UnitFemtokatals {
    type Output = UnitFemtokatals;
    #[inline]
    fn sub(self, _: UnitFemtokatals) -> Self::Output {
        UnitFemtokatals
    }
}
impl SubAssign<UnitFemtokatals> for UnitFemtokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtokatals) {}
}
pub struct UnitFemtokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokatalsMul {
    #[inline]
    fn clone(&self) -> UnitFemtokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtokatalsMul> for i8 {
    type Output = Quantity<i8, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for i16 {
    type Output = Quantity<i16, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for i32 {
    type Output = Quantity<i32, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for i64 {
    type Output = Quantity<i64, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for i128 {
    type Output = Quantity<i128, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for isize {
    type Output = Quantity<isize, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for u8 {
    type Output = Quantity<u8, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for u16 {
    type Output = Quantity<u16, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for u32 {
    type Output = Quantity<u32, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for u64 {
    type Output = Quantity<u64, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for u128 {
    type Output = Quantity<u128, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for usize {
    type Output = Quantity<usize, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for f32 {
    type Output = Quantity<f32, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
impl Mul<UnitFemtokatalsMul> for f64 {
    type Output = Quantity<f64, UnitFemtokatals>;
    fn mul(self, _: UnitFemtokatalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtokatals)
    }
}
pub struct UnitAttokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokatals {
    #[inline]
    fn clone(&self) -> UnitAttokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokatals {
    #[inline]
    fn eq(&self, other: &UnitAttokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttokatals {
    fn default() -> Self {
        UnitAttokatals
    }
}
impl Add<UnitAttokatals> for UnitAttokatals {
    type Output = UnitAttokatals;
    #[inline]
    fn add(self, _: UnitAttokatals) -> Self::Output {
        UnitAttokatals
    }
}
impl AddAssign<UnitAttokatals> for UnitAttokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitAttokatals) {}
}
impl Sub<UnitAttokatals> for UnitAttokatals {
    type Output = UnitAttokatals;
    #[inline]
    fn sub(self, _: UnitAttokatals) -> Self::Output {
        UnitAttokatals
    }
}
impl SubAssign<UnitAttokatals> for UnitAttokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttokatals) {}
}
pub struct UnitAttokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokatalsMul {
    #[inline]
    fn clone(&self) -> UnitAttokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitAttokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttokatalsMul> for i8 {
    type Output = Quantity<i8, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for i16 {
    type Output = Quantity<i16, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for i32 {
    type Output = Quantity<i32, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for i64 {
    type Output = Quantity<i64, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for i128 {
    type Output = Quantity<i128, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for isize {
    type Output = Quantity<isize, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for u8 {
    type Output = Quantity<u8, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for u16 {
    type Output = Quantity<u16, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for u32 {
    type Output = Quantity<u32, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for u64 {
    type Output = Quantity<u64, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for u128 {
    type Output = Quantity<u128, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for usize {
    type Output = Quantity<usize, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for f32 {
    type Output = Quantity<f32, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
impl Mul<UnitAttokatalsMul> for f64 {
    type Output = Quantity<f64, UnitAttokatals>;
    fn mul(self, _: UnitAttokatalsMul) -> Self::Output {
        Quantity::new(self, UnitAttokatals)
    }
}
pub struct UnitZeptokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokatals {
    #[inline]
    fn clone(&self) -> UnitZeptokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokatals {
    #[inline]
    fn eq(&self, other: &UnitZeptokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptokatals {
    fn default() -> Self {
        UnitZeptokatals
    }
}
impl Add<UnitZeptokatals> for UnitZeptokatals {
    type Output = UnitZeptokatals;
    #[inline]
    fn add(self, _: UnitZeptokatals) -> Self::Output {
        UnitZeptokatals
    }
}
impl AddAssign<UnitZeptokatals> for UnitZeptokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptokatals) {}
}
impl Sub<UnitZeptokatals> for UnitZeptokatals {
    type Output = UnitZeptokatals;
    #[inline]
    fn sub(self, _: UnitZeptokatals) -> Self::Output {
        UnitZeptokatals
    }
}
impl SubAssign<UnitZeptokatals> for UnitZeptokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptokatals) {}
}
pub struct UnitZeptokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokatalsMul {
    #[inline]
    fn clone(&self) -> UnitZeptokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptokatalsMul> for i8 {
    type Output = Quantity<i8, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for i16 {
    type Output = Quantity<i16, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for i32 {
    type Output = Quantity<i32, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for i64 {
    type Output = Quantity<i64, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for i128 {
    type Output = Quantity<i128, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for isize {
    type Output = Quantity<isize, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for u8 {
    type Output = Quantity<u8, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for u16 {
    type Output = Quantity<u16, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for u32 {
    type Output = Quantity<u32, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for u64 {
    type Output = Quantity<u64, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for u128 {
    type Output = Quantity<u128, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for usize {
    type Output = Quantity<usize, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for f32 {
    type Output = Quantity<f32, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
impl Mul<UnitZeptokatalsMul> for f64 {
    type Output = Quantity<f64, UnitZeptokatals>;
    fn mul(self, _: UnitZeptokatalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptokatals)
    }
}
pub struct UnitYoctokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokatals {
    #[inline]
    fn clone(&self) -> UnitYoctokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokatals {
    #[inline]
    fn eq(&self, other: &UnitYoctokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctokatals {
    fn default() -> Self {
        UnitYoctokatals
    }
}
impl Add<UnitYoctokatals> for UnitYoctokatals {
    type Output = UnitYoctokatals;
    #[inline]
    fn add(self, _: UnitYoctokatals) -> Self::Output {
        UnitYoctokatals
    }
}
impl AddAssign<UnitYoctokatals> for UnitYoctokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctokatals) {}
}
impl Sub<UnitYoctokatals> for UnitYoctokatals {
    type Output = UnitYoctokatals;
    #[inline]
    fn sub(self, _: UnitYoctokatals) -> Self::Output {
        UnitYoctokatals
    }
}
impl SubAssign<UnitYoctokatals> for UnitYoctokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctokatals) {}
}
pub struct UnitYoctokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokatalsMul {
    #[inline]
    fn clone(&self) -> UnitYoctokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctokatalsMul> for i8 {
    type Output = Quantity<i8, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for i16 {
    type Output = Quantity<i16, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for i32 {
    type Output = Quantity<i32, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for i64 {
    type Output = Quantity<i64, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for i128 {
    type Output = Quantity<i128, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for isize {
    type Output = Quantity<isize, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for u8 {
    type Output = Quantity<u8, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for u16 {
    type Output = Quantity<u16, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for u32 {
    type Output = Quantity<u32, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for u64 {
    type Output = Quantity<u64, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for u128 {
    type Output = Quantity<u128, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for usize {
    type Output = Quantity<usize, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for f32 {
    type Output = Quantity<f32, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
impl Mul<UnitYoctokatalsMul> for f64 {
    type Output = Quantity<f64, UnitYoctokatals>;
    fn mul(self, _: UnitYoctokatalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctokatals)
    }
}
pub struct UnitRontokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokatals {
    #[inline]
    fn clone(&self) -> UnitRontokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokatals {
    #[inline]
    fn eq(&self, other: &UnitRontokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontokatals {
    fn default() -> Self {
        UnitRontokatals
    }
}
impl Add<UnitRontokatals> for UnitRontokatals {
    type Output = UnitRontokatals;
    #[inline]
    fn add(self, _: UnitRontokatals) -> Self::Output {
        UnitRontokatals
    }
}
impl AddAssign<UnitRontokatals> for UnitRontokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitRontokatals) {}
}
impl Sub<UnitRontokatals> for UnitRontokatals {
    type Output = UnitRontokatals;
    #[inline]
    fn sub(self, _: UnitRontokatals) -> Self::Output {
        UnitRontokatals
    }
}
impl SubAssign<UnitRontokatals> for UnitRontokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontokatals) {}
}
pub struct UnitRontokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokatalsMul {
    #[inline]
    fn clone(&self) -> UnitRontokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitRontokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontokatalsMul> for i8 {
    type Output = Quantity<i8, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for i16 {
    type Output = Quantity<i16, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for i32 {
    type Output = Quantity<i32, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for i64 {
    type Output = Quantity<i64, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for i128 {
    type Output = Quantity<i128, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for isize {
    type Output = Quantity<isize, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for u8 {
    type Output = Quantity<u8, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for u16 {
    type Output = Quantity<u16, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for u32 {
    type Output = Quantity<u32, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for u64 {
    type Output = Quantity<u64, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for u128 {
    type Output = Quantity<u128, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for usize {
    type Output = Quantity<usize, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for f32 {
    type Output = Quantity<f32, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
impl Mul<UnitRontokatalsMul> for f64 {
    type Output = Quantity<f64, UnitRontokatals>;
    fn mul(self, _: UnitRontokatalsMul) -> Self::Output {
        Quantity::new(self, UnitRontokatals)
    }
}
pub struct UnitQuectokatals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokatals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokatals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokatals {
    #[inline]
    fn clone(&self) -> UnitQuectokatals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokatals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokatals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokatals {
    #[inline]
    fn eq(&self, other: &UnitQuectokatals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokatals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectokatals {
    fn default() -> Self {
        UnitQuectokatals
    }
}
impl Add<UnitQuectokatals> for UnitQuectokatals {
    type Output = UnitQuectokatals;
    #[inline]
    fn add(self, _: UnitQuectokatals) -> Self::Output {
        UnitQuectokatals
    }
}
impl AddAssign<UnitQuectokatals> for UnitQuectokatals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectokatals) {}
}
impl Sub<UnitQuectokatals> for UnitQuectokatals {
    type Output = UnitQuectokatals;
    #[inline]
    fn sub(self, _: UnitQuectokatals) -> Self::Output {
        UnitQuectokatals
    }
}
impl SubAssign<UnitQuectokatals> for UnitQuectokatals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectokatals) {}
}
pub struct UnitQuectokatalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokatalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokatalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokatalsMul {
    #[inline]
    fn clone(&self) -> UnitQuectokatalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokatalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokatalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokatalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectokatalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokatalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectokatalsMul> for i8 {
    type Output = Quantity<i8, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for i16 {
    type Output = Quantity<i16, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for i32 {
    type Output = Quantity<i32, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for i64 {
    type Output = Quantity<i64, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for i128 {
    type Output = Quantity<i128, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for isize {
    type Output = Quantity<isize, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for u8 {
    type Output = Quantity<u8, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for u16 {
    type Output = Quantity<u16, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for u32 {
    type Output = Quantity<u32, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for u64 {
    type Output = Quantity<u64, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for u128 {
    type Output = Quantity<u128, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for usize {
    type Output = Quantity<usize, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for f32 {
    type Output = Quantity<f32, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
impl Mul<UnitQuectokatalsMul> for f64 {
    type Output = Quantity<f64, UnitQuectokatals>;
    fn mul(self, _: UnitQuectokatalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectokatals)
    }
}
pub type Katals<T> = Quantity<T, UnitKatals>;
#[allow(non_upper_case_globals)]
pub static Katals: UnitKatalsMul = UnitKatalsMul;
pub type Quettakatals<T> = Quantity<T, UnitQuettakatals>;
#[allow(non_upper_case_globals)]
pub static Quettakatals: UnitQuettakatalsMul = UnitQuettakatalsMul;
pub type Ronnakatals<T> = Quantity<T, UnitRonnakatals>;
#[allow(non_upper_case_globals)]
pub static Ronnakatals: UnitRonnakatalsMul = UnitRonnakatalsMul;
pub type Yottakatals<T> = Quantity<T, UnitYottakatals>;
#[allow(non_upper_case_globals)]
pub static Yottakatals: UnitYottakatalsMul = UnitYottakatalsMul;
pub type Zettakatals<T> = Quantity<T, UnitZettakatals>;
#[allow(non_upper_case_globals)]
pub static Zettakatals: UnitZettakatalsMul = UnitZettakatalsMul;
pub type Exakatals<T> = Quantity<T, UnitExakatals>;
#[allow(non_upper_case_globals)]
pub static Exakatals: UnitExakatalsMul = UnitExakatalsMul;
pub type Petakatals<T> = Quantity<T, UnitPetakatals>;
#[allow(non_upper_case_globals)]
pub static Petakatals: UnitPetakatalsMul = UnitPetakatalsMul;
pub type Terakatals<T> = Quantity<T, UnitTerakatals>;
#[allow(non_upper_case_globals)]
pub static Terakatals: UnitTerakatalsMul = UnitTerakatalsMul;
pub type Gigakatals<T> = Quantity<T, UnitGigakatals>;
#[allow(non_upper_case_globals)]
pub static Gigakatals: UnitGigakatalsMul = UnitGigakatalsMul;
pub type Megakatals<T> = Quantity<T, UnitMegakatals>;
#[allow(non_upper_case_globals)]
pub static Megakatals: UnitMegakatalsMul = UnitMegakatalsMul;
pub type Kilokatals<T> = Quantity<T, UnitKilokatals>;
#[allow(non_upper_case_globals)]
pub static Kilokatals: UnitKilokatalsMul = UnitKilokatalsMul;
pub type Hectokatals<T> = Quantity<T, UnitHectokatals>;
#[allow(non_upper_case_globals)]
pub static Hectokatals: UnitHectokatalsMul = UnitHectokatalsMul;
pub type Decakatals<T> = Quantity<T, UnitDecakatals>;
#[allow(non_upper_case_globals)]
pub static Decakatals: UnitDecakatalsMul = UnitDecakatalsMul;
pub type Decikatals<T> = Quantity<T, UnitDecikatals>;
#[allow(non_upper_case_globals)]
pub static Decikatals: UnitDecikatalsMul = UnitDecikatalsMul;
pub type Centikatals<T> = Quantity<T, UnitCentikatals>;
#[allow(non_upper_case_globals)]
pub static Centikatals: UnitCentikatalsMul = UnitCentikatalsMul;
pub type Millikatals<T> = Quantity<T, UnitMillikatals>;
#[allow(non_upper_case_globals)]
pub static Millikatals: UnitMillikatalsMul = UnitMillikatalsMul;
pub type Microkatals<T> = Quantity<T, UnitMicrokatals>;
#[allow(non_upper_case_globals)]
pub static Microkatals: UnitMicrokatalsMul = UnitMicrokatalsMul;
pub type Nanokatals<T> = Quantity<T, UnitNanokatals>;
#[allow(non_upper_case_globals)]
pub static Nanokatals: UnitNanokatalsMul = UnitNanokatalsMul;
pub type Picokatals<T> = Quantity<T, UnitPicokatals>;
#[allow(non_upper_case_globals)]
pub static Picokatals: UnitPicokatalsMul = UnitPicokatalsMul;
pub type Femtokatals<T> = Quantity<T, UnitFemtokatals>;
#[allow(non_upper_case_globals)]
pub static Femtokatals: UnitFemtokatalsMul = UnitFemtokatalsMul;
pub type Attokatals<T> = Quantity<T, UnitAttokatals>;
#[allow(non_upper_case_globals)]
pub static Attokatals: UnitAttokatalsMul = UnitAttokatalsMul;
pub type Zeptokatals<T> = Quantity<T, UnitZeptokatals>;
#[allow(non_upper_case_globals)]
pub static Zeptokatals: UnitZeptokatalsMul = UnitZeptokatalsMul;
pub type Yoctokatals<T> = Quantity<T, UnitYoctokatals>;
#[allow(non_upper_case_globals)]
pub static Yoctokatals: UnitYoctokatalsMul = UnitYoctokatalsMul;
pub type Rontokatals<T> = Quantity<T, UnitRontokatals>;
#[allow(non_upper_case_globals)]
pub static Rontokatals: UnitRontokatalsMul = UnitRontokatalsMul;
pub type Quectokatals<T> = Quantity<T, UnitQuectokatals>;
#[allow(non_upper_case_globals)]
pub static Quectokatals: UnitQuectokatalsMul = UnitQuectokatalsMul;
pub struct UnitKaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKaysers {
    #[inline]
    fn clone(&self) -> UnitKaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKaysers {
    #[inline]
    fn eq(&self, other: &UnitKaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKaysers {
    fn default() -> Self {
        UnitKaysers
    }
}
impl Add<UnitKaysers> for UnitKaysers {
    type Output = UnitKaysers;
    #[inline]
    fn add(self, _: UnitKaysers) -> Self::Output {
        UnitKaysers
    }
}
impl AddAssign<UnitKaysers> for UnitKaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitKaysers) {}
}
impl Sub<UnitKaysers> for UnitKaysers {
    type Output = UnitKaysers;
    #[inline]
    fn sub(self, _: UnitKaysers) -> Self::Output {
        UnitKaysers
    }
}
impl SubAssign<UnitKaysers> for UnitKaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitKaysers) {}
}
pub struct UnitKaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKaysersMul {
    #[inline]
    fn clone(&self) -> UnitKaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKaysersMul {
    #[inline]
    fn eq(&self, other: &UnitKaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKaysersMul> for i8 {
    type Output = Quantity<i8, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for i16 {
    type Output = Quantity<i16, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for i32 {
    type Output = Quantity<i32, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for i64 {
    type Output = Quantity<i64, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for i128 {
    type Output = Quantity<i128, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for isize {
    type Output = Quantity<isize, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for u8 {
    type Output = Quantity<u8, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for u16 {
    type Output = Quantity<u16, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for u32 {
    type Output = Quantity<u32, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for u64 {
    type Output = Quantity<u64, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for u128 {
    type Output = Quantity<u128, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for usize {
    type Output = Quantity<usize, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for f32 {
    type Output = Quantity<f32, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
impl Mul<UnitKaysersMul> for f64 {
    type Output = Quantity<f64, UnitKaysers>;
    fn mul(self, _: UnitKaysersMul) -> Self::Output {
        Quantity::new(self, UnitKaysers)
    }
}
pub struct UnitQuettakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakaysers {
    #[inline]
    fn clone(&self) -> UnitQuettakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakaysers {
    #[inline]
    fn eq(&self, other: &UnitQuettakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettakaysers {
    fn default() -> Self {
        UnitQuettakaysers
    }
}
impl Add<UnitQuettakaysers> for UnitQuettakaysers {
    type Output = UnitQuettakaysers;
    #[inline]
    fn add(self, _: UnitQuettakaysers) -> Self::Output {
        UnitQuettakaysers
    }
}
impl AddAssign<UnitQuettakaysers> for UnitQuettakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettakaysers) {}
}
impl Sub<UnitQuettakaysers> for UnitQuettakaysers {
    type Output = UnitQuettakaysers;
    #[inline]
    fn sub(self, _: UnitQuettakaysers) -> Self::Output {
        UnitQuettakaysers
    }
}
impl SubAssign<UnitQuettakaysers> for UnitQuettakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettakaysers) {}
}
pub struct UnitQuettakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettakaysersMul {
    #[inline]
    fn clone(&self) -> UnitQuettakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitQuettakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettakaysersMul> for i8 {
    type Output = Quantity<i8, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for i16 {
    type Output = Quantity<i16, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for i32 {
    type Output = Quantity<i32, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for i64 {
    type Output = Quantity<i64, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for i128 {
    type Output = Quantity<i128, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for isize {
    type Output = Quantity<isize, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for u8 {
    type Output = Quantity<u8, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for u16 {
    type Output = Quantity<u16, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for u32 {
    type Output = Quantity<u32, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for u64 {
    type Output = Quantity<u64, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for u128 {
    type Output = Quantity<u128, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for usize {
    type Output = Quantity<usize, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for f32 {
    type Output = Quantity<f32, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
impl Mul<UnitQuettakaysersMul> for f64 {
    type Output = Quantity<f64, UnitQuettakaysers>;
    fn mul(self, _: UnitQuettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuettakaysers)
    }
}
pub struct UnitRonnakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakaysers {
    #[inline]
    fn clone(&self) -> UnitRonnakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakaysers {
    #[inline]
    fn eq(&self, other: &UnitRonnakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnakaysers {
    fn default() -> Self {
        UnitRonnakaysers
    }
}
impl Add<UnitRonnakaysers> for UnitRonnakaysers {
    type Output = UnitRonnakaysers;
    #[inline]
    fn add(self, _: UnitRonnakaysers) -> Self::Output {
        UnitRonnakaysers
    }
}
impl AddAssign<UnitRonnakaysers> for UnitRonnakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnakaysers) {}
}
impl Sub<UnitRonnakaysers> for UnitRonnakaysers {
    type Output = UnitRonnakaysers;
    #[inline]
    fn sub(self, _: UnitRonnakaysers) -> Self::Output {
        UnitRonnakaysers
    }
}
impl SubAssign<UnitRonnakaysers> for UnitRonnakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnakaysers) {}
}
pub struct UnitRonnakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnakaysersMul {
    #[inline]
    fn clone(&self) -> UnitRonnakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitRonnakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnakaysersMul> for i8 {
    type Output = Quantity<i8, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for i16 {
    type Output = Quantity<i16, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for i32 {
    type Output = Quantity<i32, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for i64 {
    type Output = Quantity<i64, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for i128 {
    type Output = Quantity<i128, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for isize {
    type Output = Quantity<isize, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for u8 {
    type Output = Quantity<u8, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for u16 {
    type Output = Quantity<u16, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for u32 {
    type Output = Quantity<u32, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for u64 {
    type Output = Quantity<u64, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for u128 {
    type Output = Quantity<u128, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for usize {
    type Output = Quantity<usize, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for f32 {
    type Output = Quantity<f32, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
impl Mul<UnitRonnakaysersMul> for f64 {
    type Output = Quantity<f64, UnitRonnakaysers>;
    fn mul(self, _: UnitRonnakaysersMul) -> Self::Output {
        Quantity::new(self, UnitRonnakaysers)
    }
}
pub struct UnitYottakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakaysers {
    #[inline]
    fn clone(&self) -> UnitYottakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakaysers {
    #[inline]
    fn eq(&self, other: &UnitYottakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottakaysers {
    fn default() -> Self {
        UnitYottakaysers
    }
}
impl Add<UnitYottakaysers> for UnitYottakaysers {
    type Output = UnitYottakaysers;
    #[inline]
    fn add(self, _: UnitYottakaysers) -> Self::Output {
        UnitYottakaysers
    }
}
impl AddAssign<UnitYottakaysers> for UnitYottakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitYottakaysers) {}
}
impl Sub<UnitYottakaysers> for UnitYottakaysers {
    type Output = UnitYottakaysers;
    #[inline]
    fn sub(self, _: UnitYottakaysers) -> Self::Output {
        UnitYottakaysers
    }
}
impl SubAssign<UnitYottakaysers> for UnitYottakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottakaysers) {}
}
pub struct UnitYottakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottakaysersMul {
    #[inline]
    fn clone(&self) -> UnitYottakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitYottakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottakaysersMul> for i8 {
    type Output = Quantity<i8, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for i16 {
    type Output = Quantity<i16, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for i32 {
    type Output = Quantity<i32, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for i64 {
    type Output = Quantity<i64, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for i128 {
    type Output = Quantity<i128, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for isize {
    type Output = Quantity<isize, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for u8 {
    type Output = Quantity<u8, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for u16 {
    type Output = Quantity<u16, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for u32 {
    type Output = Quantity<u32, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for u64 {
    type Output = Quantity<u64, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for u128 {
    type Output = Quantity<u128, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for usize {
    type Output = Quantity<usize, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for f32 {
    type Output = Quantity<f32, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
impl Mul<UnitYottakaysersMul> for f64 {
    type Output = Quantity<f64, UnitYottakaysers>;
    fn mul(self, _: UnitYottakaysersMul) -> Self::Output {
        Quantity::new(self, UnitYottakaysers)
    }
}
pub struct UnitZettakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakaysers {
    #[inline]
    fn clone(&self) -> UnitZettakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakaysers {
    #[inline]
    fn eq(&self, other: &UnitZettakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettakaysers {
    fn default() -> Self {
        UnitZettakaysers
    }
}
impl Add<UnitZettakaysers> for UnitZettakaysers {
    type Output = UnitZettakaysers;
    #[inline]
    fn add(self, _: UnitZettakaysers) -> Self::Output {
        UnitZettakaysers
    }
}
impl AddAssign<UnitZettakaysers> for UnitZettakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitZettakaysers) {}
}
impl Sub<UnitZettakaysers> for UnitZettakaysers {
    type Output = UnitZettakaysers;
    #[inline]
    fn sub(self, _: UnitZettakaysers) -> Self::Output {
        UnitZettakaysers
    }
}
impl SubAssign<UnitZettakaysers> for UnitZettakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettakaysers) {}
}
pub struct UnitZettakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettakaysersMul {
    #[inline]
    fn clone(&self) -> UnitZettakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitZettakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettakaysersMul> for i8 {
    type Output = Quantity<i8, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for i16 {
    type Output = Quantity<i16, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for i32 {
    type Output = Quantity<i32, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for i64 {
    type Output = Quantity<i64, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for i128 {
    type Output = Quantity<i128, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for isize {
    type Output = Quantity<isize, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for u8 {
    type Output = Quantity<u8, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for u16 {
    type Output = Quantity<u16, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for u32 {
    type Output = Quantity<u32, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for u64 {
    type Output = Quantity<u64, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for u128 {
    type Output = Quantity<u128, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for usize {
    type Output = Quantity<usize, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for f32 {
    type Output = Quantity<f32, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
impl Mul<UnitZettakaysersMul> for f64 {
    type Output = Quantity<f64, UnitZettakaysers>;
    fn mul(self, _: UnitZettakaysersMul) -> Self::Output {
        Quantity::new(self, UnitZettakaysers)
    }
}
pub struct UnitExakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakaysers {
    #[inline]
    fn clone(&self) -> UnitExakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakaysers {
    #[inline]
    fn eq(&self, other: &UnitExakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExakaysers {
    fn default() -> Self {
        UnitExakaysers
    }
}
impl Add<UnitExakaysers> for UnitExakaysers {
    type Output = UnitExakaysers;
    #[inline]
    fn add(self, _: UnitExakaysers) -> Self::Output {
        UnitExakaysers
    }
}
impl AddAssign<UnitExakaysers> for UnitExakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitExakaysers) {}
}
impl Sub<UnitExakaysers> for UnitExakaysers {
    type Output = UnitExakaysers;
    #[inline]
    fn sub(self, _: UnitExakaysers) -> Self::Output {
        UnitExakaysers
    }
}
impl SubAssign<UnitExakaysers> for UnitExakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitExakaysers) {}
}
pub struct UnitExakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExakaysersMul {
    #[inline]
    fn clone(&self) -> UnitExakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitExakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExakaysersMul> for i8 {
    type Output = Quantity<i8, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for i16 {
    type Output = Quantity<i16, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for i32 {
    type Output = Quantity<i32, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for i64 {
    type Output = Quantity<i64, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for i128 {
    type Output = Quantity<i128, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for isize {
    type Output = Quantity<isize, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for u8 {
    type Output = Quantity<u8, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for u16 {
    type Output = Quantity<u16, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for u32 {
    type Output = Quantity<u32, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for u64 {
    type Output = Quantity<u64, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for u128 {
    type Output = Quantity<u128, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for usize {
    type Output = Quantity<usize, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for f32 {
    type Output = Quantity<f32, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
impl Mul<UnitExakaysersMul> for f64 {
    type Output = Quantity<f64, UnitExakaysers>;
    fn mul(self, _: UnitExakaysersMul) -> Self::Output {
        Quantity::new(self, UnitExakaysers)
    }
}
pub struct UnitPetakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakaysers {
    #[inline]
    fn clone(&self) -> UnitPetakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakaysers {
    #[inline]
    fn eq(&self, other: &UnitPetakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetakaysers {
    fn default() -> Self {
        UnitPetakaysers
    }
}
impl Add<UnitPetakaysers> for UnitPetakaysers {
    type Output = UnitPetakaysers;
    #[inline]
    fn add(self, _: UnitPetakaysers) -> Self::Output {
        UnitPetakaysers
    }
}
impl AddAssign<UnitPetakaysers> for UnitPetakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitPetakaysers) {}
}
impl Sub<UnitPetakaysers> for UnitPetakaysers {
    type Output = UnitPetakaysers;
    #[inline]
    fn sub(self, _: UnitPetakaysers) -> Self::Output {
        UnitPetakaysers
    }
}
impl SubAssign<UnitPetakaysers> for UnitPetakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetakaysers) {}
}
pub struct UnitPetakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetakaysersMul {
    #[inline]
    fn clone(&self) -> UnitPetakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitPetakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetakaysersMul> for i8 {
    type Output = Quantity<i8, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for i16 {
    type Output = Quantity<i16, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for i32 {
    type Output = Quantity<i32, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for i64 {
    type Output = Quantity<i64, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for i128 {
    type Output = Quantity<i128, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for isize {
    type Output = Quantity<isize, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for u8 {
    type Output = Quantity<u8, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for u16 {
    type Output = Quantity<u16, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for u32 {
    type Output = Quantity<u32, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for u64 {
    type Output = Quantity<u64, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for u128 {
    type Output = Quantity<u128, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for usize {
    type Output = Quantity<usize, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for f32 {
    type Output = Quantity<f32, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
impl Mul<UnitPetakaysersMul> for f64 {
    type Output = Quantity<f64, UnitPetakaysers>;
    fn mul(self, _: UnitPetakaysersMul) -> Self::Output {
        Quantity::new(self, UnitPetakaysers)
    }
}
pub struct UnitTerakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakaysers {
    #[inline]
    fn clone(&self) -> UnitTerakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakaysers {
    #[inline]
    fn eq(&self, other: &UnitTerakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerakaysers {
    fn default() -> Self {
        UnitTerakaysers
    }
}
impl Add<UnitTerakaysers> for UnitTerakaysers {
    type Output = UnitTerakaysers;
    #[inline]
    fn add(self, _: UnitTerakaysers) -> Self::Output {
        UnitTerakaysers
    }
}
impl AddAssign<UnitTerakaysers> for UnitTerakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitTerakaysers) {}
}
impl Sub<UnitTerakaysers> for UnitTerakaysers {
    type Output = UnitTerakaysers;
    #[inline]
    fn sub(self, _: UnitTerakaysers) -> Self::Output {
        UnitTerakaysers
    }
}
impl SubAssign<UnitTerakaysers> for UnitTerakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerakaysers) {}
}
pub struct UnitTerakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerakaysersMul {
    #[inline]
    fn clone(&self) -> UnitTerakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitTerakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerakaysersMul> for i8 {
    type Output = Quantity<i8, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for i16 {
    type Output = Quantity<i16, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for i32 {
    type Output = Quantity<i32, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for i64 {
    type Output = Quantity<i64, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for i128 {
    type Output = Quantity<i128, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for isize {
    type Output = Quantity<isize, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for u8 {
    type Output = Quantity<u8, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for u16 {
    type Output = Quantity<u16, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for u32 {
    type Output = Quantity<u32, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for u64 {
    type Output = Quantity<u64, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for u128 {
    type Output = Quantity<u128, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for usize {
    type Output = Quantity<usize, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for f32 {
    type Output = Quantity<f32, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
impl Mul<UnitTerakaysersMul> for f64 {
    type Output = Quantity<f64, UnitTerakaysers>;
    fn mul(self, _: UnitTerakaysersMul) -> Self::Output {
        Quantity::new(self, UnitTerakaysers)
    }
}
pub struct UnitGigakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakaysers {
    #[inline]
    fn clone(&self) -> UnitGigakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakaysers {
    #[inline]
    fn eq(&self, other: &UnitGigakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigakaysers {
    fn default() -> Self {
        UnitGigakaysers
    }
}
impl Add<UnitGigakaysers> for UnitGigakaysers {
    type Output = UnitGigakaysers;
    #[inline]
    fn add(self, _: UnitGigakaysers) -> Self::Output {
        UnitGigakaysers
    }
}
impl AddAssign<UnitGigakaysers> for UnitGigakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitGigakaysers) {}
}
impl Sub<UnitGigakaysers> for UnitGigakaysers {
    type Output = UnitGigakaysers;
    #[inline]
    fn sub(self, _: UnitGigakaysers) -> Self::Output {
        UnitGigakaysers
    }
}
impl SubAssign<UnitGigakaysers> for UnitGigakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigakaysers) {}
}
pub struct UnitGigakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigakaysersMul {
    #[inline]
    fn clone(&self) -> UnitGigakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitGigakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigakaysersMul> for i8 {
    type Output = Quantity<i8, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for i16 {
    type Output = Quantity<i16, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for i32 {
    type Output = Quantity<i32, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for i64 {
    type Output = Quantity<i64, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for i128 {
    type Output = Quantity<i128, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for isize {
    type Output = Quantity<isize, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for u8 {
    type Output = Quantity<u8, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for u16 {
    type Output = Quantity<u16, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for u32 {
    type Output = Quantity<u32, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for u64 {
    type Output = Quantity<u64, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for u128 {
    type Output = Quantity<u128, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for usize {
    type Output = Quantity<usize, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for f32 {
    type Output = Quantity<f32, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
impl Mul<UnitGigakaysersMul> for f64 {
    type Output = Quantity<f64, UnitGigakaysers>;
    fn mul(self, _: UnitGigakaysersMul) -> Self::Output {
        Quantity::new(self, UnitGigakaysers)
    }
}
pub struct UnitMegakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakaysers {
    #[inline]
    fn clone(&self) -> UnitMegakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakaysers {
    #[inline]
    fn eq(&self, other: &UnitMegakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegakaysers {
    fn default() -> Self {
        UnitMegakaysers
    }
}
impl Add<UnitMegakaysers> for UnitMegakaysers {
    type Output = UnitMegakaysers;
    #[inline]
    fn add(self, _: UnitMegakaysers) -> Self::Output {
        UnitMegakaysers
    }
}
impl AddAssign<UnitMegakaysers> for UnitMegakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitMegakaysers) {}
}
impl Sub<UnitMegakaysers> for UnitMegakaysers {
    type Output = UnitMegakaysers;
    #[inline]
    fn sub(self, _: UnitMegakaysers) -> Self::Output {
        UnitMegakaysers
    }
}
impl SubAssign<UnitMegakaysers> for UnitMegakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegakaysers) {}
}
pub struct UnitMegakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegakaysersMul {
    #[inline]
    fn clone(&self) -> UnitMegakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitMegakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegakaysersMul> for i8 {
    type Output = Quantity<i8, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for i16 {
    type Output = Quantity<i16, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for i32 {
    type Output = Quantity<i32, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for i64 {
    type Output = Quantity<i64, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for i128 {
    type Output = Quantity<i128, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for isize {
    type Output = Quantity<isize, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for u8 {
    type Output = Quantity<u8, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for u16 {
    type Output = Quantity<u16, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for u32 {
    type Output = Quantity<u32, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for u64 {
    type Output = Quantity<u64, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for u128 {
    type Output = Quantity<u128, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for usize {
    type Output = Quantity<usize, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for f32 {
    type Output = Quantity<f32, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
impl Mul<UnitMegakaysersMul> for f64 {
    type Output = Quantity<f64, UnitMegakaysers>;
    fn mul(self, _: UnitMegakaysersMul) -> Self::Output {
        Quantity::new(self, UnitMegakaysers)
    }
}
pub struct UnitKilokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokaysers {
    #[inline]
    fn clone(&self) -> UnitKilokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokaysers {
    #[inline]
    fn eq(&self, other: &UnitKilokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilokaysers {
    fn default() -> Self {
        UnitKilokaysers
    }
}
impl Add<UnitKilokaysers> for UnitKilokaysers {
    type Output = UnitKilokaysers;
    #[inline]
    fn add(self, _: UnitKilokaysers) -> Self::Output {
        UnitKilokaysers
    }
}
impl AddAssign<UnitKilokaysers> for UnitKilokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitKilokaysers) {}
}
impl Sub<UnitKilokaysers> for UnitKilokaysers {
    type Output = UnitKilokaysers;
    #[inline]
    fn sub(self, _: UnitKilokaysers) -> Self::Output {
        UnitKilokaysers
    }
}
impl SubAssign<UnitKilokaysers> for UnitKilokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilokaysers) {}
}
pub struct UnitKilokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilokaysersMul {
    #[inline]
    fn clone(&self) -> UnitKilokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitKilokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilokaysersMul> for i8 {
    type Output = Quantity<i8, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for i16 {
    type Output = Quantity<i16, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for i32 {
    type Output = Quantity<i32, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for i64 {
    type Output = Quantity<i64, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for i128 {
    type Output = Quantity<i128, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for isize {
    type Output = Quantity<isize, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for u8 {
    type Output = Quantity<u8, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for u16 {
    type Output = Quantity<u16, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for u32 {
    type Output = Quantity<u32, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for u64 {
    type Output = Quantity<u64, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for u128 {
    type Output = Quantity<u128, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for usize {
    type Output = Quantity<usize, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for f32 {
    type Output = Quantity<f32, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
impl Mul<UnitKilokaysersMul> for f64 {
    type Output = Quantity<f64, UnitKilokaysers>;
    fn mul(self, _: UnitKilokaysersMul) -> Self::Output {
        Quantity::new(self, UnitKilokaysers)
    }
}
pub struct UnitHectokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokaysers {
    #[inline]
    fn clone(&self) -> UnitHectokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokaysers {
    #[inline]
    fn eq(&self, other: &UnitHectokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectokaysers {
    fn default() -> Self {
        UnitHectokaysers
    }
}
impl Add<UnitHectokaysers> for UnitHectokaysers {
    type Output = UnitHectokaysers;
    #[inline]
    fn add(self, _: UnitHectokaysers) -> Self::Output {
        UnitHectokaysers
    }
}
impl AddAssign<UnitHectokaysers> for UnitHectokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitHectokaysers) {}
}
impl Sub<UnitHectokaysers> for UnitHectokaysers {
    type Output = UnitHectokaysers;
    #[inline]
    fn sub(self, _: UnitHectokaysers) -> Self::Output {
        UnitHectokaysers
    }
}
impl SubAssign<UnitHectokaysers> for UnitHectokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectokaysers) {}
}
pub struct UnitHectokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectokaysersMul {
    #[inline]
    fn clone(&self) -> UnitHectokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitHectokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectokaysersMul> for i8 {
    type Output = Quantity<i8, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for i16 {
    type Output = Quantity<i16, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for i32 {
    type Output = Quantity<i32, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for i64 {
    type Output = Quantity<i64, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for i128 {
    type Output = Quantity<i128, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for isize {
    type Output = Quantity<isize, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for u8 {
    type Output = Quantity<u8, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for u16 {
    type Output = Quantity<u16, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for u32 {
    type Output = Quantity<u32, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for u64 {
    type Output = Quantity<u64, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for u128 {
    type Output = Quantity<u128, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for usize {
    type Output = Quantity<usize, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for f32 {
    type Output = Quantity<f32, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
impl Mul<UnitHectokaysersMul> for f64 {
    type Output = Quantity<f64, UnitHectokaysers>;
    fn mul(self, _: UnitHectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitHectokaysers)
    }
}
pub struct UnitDecakaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakaysers {
    #[inline]
    fn clone(&self) -> UnitDecakaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakaysers {
    #[inline]
    fn eq(&self, other: &UnitDecakaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecakaysers {
    fn default() -> Self {
        UnitDecakaysers
    }
}
impl Add<UnitDecakaysers> for UnitDecakaysers {
    type Output = UnitDecakaysers;
    #[inline]
    fn add(self, _: UnitDecakaysers) -> Self::Output {
        UnitDecakaysers
    }
}
impl AddAssign<UnitDecakaysers> for UnitDecakaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitDecakaysers) {}
}
impl Sub<UnitDecakaysers> for UnitDecakaysers {
    type Output = UnitDecakaysers;
    #[inline]
    fn sub(self, _: UnitDecakaysers) -> Self::Output {
        UnitDecakaysers
    }
}
impl SubAssign<UnitDecakaysers> for UnitDecakaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecakaysers) {}
}
pub struct UnitDecakaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecakaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecakaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecakaysersMul {
    #[inline]
    fn clone(&self) -> UnitDecakaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecakaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecakaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecakaysersMul {
    #[inline]
    fn eq(&self, other: &UnitDecakaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecakaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecakaysersMul> for i8 {
    type Output = Quantity<i8, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for i16 {
    type Output = Quantity<i16, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for i32 {
    type Output = Quantity<i32, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for i64 {
    type Output = Quantity<i64, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for i128 {
    type Output = Quantity<i128, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for isize {
    type Output = Quantity<isize, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for u8 {
    type Output = Quantity<u8, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for u16 {
    type Output = Quantity<u16, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for u32 {
    type Output = Quantity<u32, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for u64 {
    type Output = Quantity<u64, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for u128 {
    type Output = Quantity<u128, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for usize {
    type Output = Quantity<usize, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for f32 {
    type Output = Quantity<f32, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
impl Mul<UnitDecakaysersMul> for f64 {
    type Output = Quantity<f64, UnitDecakaysers>;
    fn mul(self, _: UnitDecakaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecakaysers)
    }
}
pub struct UnitDecikaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikaysers {
    #[inline]
    fn clone(&self) -> UnitDecikaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikaysers {
    #[inline]
    fn eq(&self, other: &UnitDecikaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecikaysers {
    fn default() -> Self {
        UnitDecikaysers
    }
}
impl Add<UnitDecikaysers> for UnitDecikaysers {
    type Output = UnitDecikaysers;
    #[inline]
    fn add(self, _: UnitDecikaysers) -> Self::Output {
        UnitDecikaysers
    }
}
impl AddAssign<UnitDecikaysers> for UnitDecikaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitDecikaysers) {}
}
impl Sub<UnitDecikaysers> for UnitDecikaysers {
    type Output = UnitDecikaysers;
    #[inline]
    fn sub(self, _: UnitDecikaysers) -> Self::Output {
        UnitDecikaysers
    }
}
impl SubAssign<UnitDecikaysers> for UnitDecikaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecikaysers) {}
}
pub struct UnitDecikaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecikaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecikaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecikaysersMul {
    #[inline]
    fn clone(&self) -> UnitDecikaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecikaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecikaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecikaysersMul {
    #[inline]
    fn eq(&self, other: &UnitDecikaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecikaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecikaysersMul> for i8 {
    type Output = Quantity<i8, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for i16 {
    type Output = Quantity<i16, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for i32 {
    type Output = Quantity<i32, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for i64 {
    type Output = Quantity<i64, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for i128 {
    type Output = Quantity<i128, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for isize {
    type Output = Quantity<isize, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for u8 {
    type Output = Quantity<u8, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for u16 {
    type Output = Quantity<u16, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for u32 {
    type Output = Quantity<u32, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for u64 {
    type Output = Quantity<u64, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for u128 {
    type Output = Quantity<u128, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for usize {
    type Output = Quantity<usize, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for f32 {
    type Output = Quantity<f32, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
impl Mul<UnitDecikaysersMul> for f64 {
    type Output = Quantity<f64, UnitDecikaysers>;
    fn mul(self, _: UnitDecikaysersMul) -> Self::Output {
        Quantity::new(self, UnitDecikaysers)
    }
}
pub struct UnitCentikaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikaysers {
    #[inline]
    fn clone(&self) -> UnitCentikaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikaysers {
    #[inline]
    fn eq(&self, other: &UnitCentikaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentikaysers {
    fn default() -> Self {
        UnitCentikaysers
    }
}
impl Add<UnitCentikaysers> for UnitCentikaysers {
    type Output = UnitCentikaysers;
    #[inline]
    fn add(self, _: UnitCentikaysers) -> Self::Output {
        UnitCentikaysers
    }
}
impl AddAssign<UnitCentikaysers> for UnitCentikaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitCentikaysers) {}
}
impl Sub<UnitCentikaysers> for UnitCentikaysers {
    type Output = UnitCentikaysers;
    #[inline]
    fn sub(self, _: UnitCentikaysers) -> Self::Output {
        UnitCentikaysers
    }
}
impl SubAssign<UnitCentikaysers> for UnitCentikaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentikaysers) {}
}
pub struct UnitCentikaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentikaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentikaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentikaysersMul {
    #[inline]
    fn clone(&self) -> UnitCentikaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentikaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentikaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentikaysersMul {
    #[inline]
    fn eq(&self, other: &UnitCentikaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentikaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentikaysersMul> for i8 {
    type Output = Quantity<i8, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for i16 {
    type Output = Quantity<i16, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for i32 {
    type Output = Quantity<i32, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for i64 {
    type Output = Quantity<i64, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for i128 {
    type Output = Quantity<i128, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for isize {
    type Output = Quantity<isize, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for u8 {
    type Output = Quantity<u8, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for u16 {
    type Output = Quantity<u16, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for u32 {
    type Output = Quantity<u32, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for u64 {
    type Output = Quantity<u64, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for u128 {
    type Output = Quantity<u128, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for usize {
    type Output = Quantity<usize, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for f32 {
    type Output = Quantity<f32, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
impl Mul<UnitCentikaysersMul> for f64 {
    type Output = Quantity<f64, UnitCentikaysers>;
    fn mul(self, _: UnitCentikaysersMul) -> Self::Output {
        Quantity::new(self, UnitCentikaysers)
    }
}
pub struct UnitMillikaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikaysers {
    #[inline]
    fn clone(&self) -> UnitMillikaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikaysers {
    #[inline]
    fn eq(&self, other: &UnitMillikaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillikaysers {
    fn default() -> Self {
        UnitMillikaysers
    }
}
impl Add<UnitMillikaysers> for UnitMillikaysers {
    type Output = UnitMillikaysers;
    #[inline]
    fn add(self, _: UnitMillikaysers) -> Self::Output {
        UnitMillikaysers
    }
}
impl AddAssign<UnitMillikaysers> for UnitMillikaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitMillikaysers) {}
}
impl Sub<UnitMillikaysers> for UnitMillikaysers {
    type Output = UnitMillikaysers;
    #[inline]
    fn sub(self, _: UnitMillikaysers) -> Self::Output {
        UnitMillikaysers
    }
}
impl SubAssign<UnitMillikaysers> for UnitMillikaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillikaysers) {}
}
pub struct UnitMillikaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillikaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillikaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillikaysersMul {
    #[inline]
    fn clone(&self) -> UnitMillikaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillikaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillikaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillikaysersMul {
    #[inline]
    fn eq(&self, other: &UnitMillikaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillikaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillikaysersMul> for i8 {
    type Output = Quantity<i8, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for i16 {
    type Output = Quantity<i16, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for i32 {
    type Output = Quantity<i32, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for i64 {
    type Output = Quantity<i64, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for i128 {
    type Output = Quantity<i128, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for isize {
    type Output = Quantity<isize, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for u8 {
    type Output = Quantity<u8, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for u16 {
    type Output = Quantity<u16, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for u32 {
    type Output = Quantity<u32, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for u64 {
    type Output = Quantity<u64, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for u128 {
    type Output = Quantity<u128, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for usize {
    type Output = Quantity<usize, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for f32 {
    type Output = Quantity<f32, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
impl Mul<UnitMillikaysersMul> for f64 {
    type Output = Quantity<f64, UnitMillikaysers>;
    fn mul(self, _: UnitMillikaysersMul) -> Self::Output {
        Quantity::new(self, UnitMillikaysers)
    }
}
pub struct UnitMicrokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokaysers {
    #[inline]
    fn clone(&self) -> UnitMicrokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokaysers {
    #[inline]
    fn eq(&self, other: &UnitMicrokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrokaysers {
    fn default() -> Self {
        UnitMicrokaysers
    }
}
impl Add<UnitMicrokaysers> for UnitMicrokaysers {
    type Output = UnitMicrokaysers;
    #[inline]
    fn add(self, _: UnitMicrokaysers) -> Self::Output {
        UnitMicrokaysers
    }
}
impl AddAssign<UnitMicrokaysers> for UnitMicrokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrokaysers) {}
}
impl Sub<UnitMicrokaysers> for UnitMicrokaysers {
    type Output = UnitMicrokaysers;
    #[inline]
    fn sub(self, _: UnitMicrokaysers) -> Self::Output {
        UnitMicrokaysers
    }
}
impl SubAssign<UnitMicrokaysers> for UnitMicrokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrokaysers) {}
}
pub struct UnitMicrokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrokaysersMul {
    #[inline]
    fn clone(&self) -> UnitMicrokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitMicrokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrokaysersMul> for i8 {
    type Output = Quantity<i8, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for i16 {
    type Output = Quantity<i16, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for i32 {
    type Output = Quantity<i32, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for i64 {
    type Output = Quantity<i64, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for i128 {
    type Output = Quantity<i128, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for isize {
    type Output = Quantity<isize, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for u8 {
    type Output = Quantity<u8, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for u16 {
    type Output = Quantity<u16, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for u32 {
    type Output = Quantity<u32, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for u64 {
    type Output = Quantity<u64, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for u128 {
    type Output = Quantity<u128, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for usize {
    type Output = Quantity<usize, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for f32 {
    type Output = Quantity<f32, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
impl Mul<UnitMicrokaysersMul> for f64 {
    type Output = Quantity<f64, UnitMicrokaysers>;
    fn mul(self, _: UnitMicrokaysersMul) -> Self::Output {
        Quantity::new(self, UnitMicrokaysers)
    }
}
pub struct UnitNanokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokaysers {
    #[inline]
    fn clone(&self) -> UnitNanokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokaysers {
    #[inline]
    fn eq(&self, other: &UnitNanokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanokaysers {
    fn default() -> Self {
        UnitNanokaysers
    }
}
impl Add<UnitNanokaysers> for UnitNanokaysers {
    type Output = UnitNanokaysers;
    #[inline]
    fn add(self, _: UnitNanokaysers) -> Self::Output {
        UnitNanokaysers
    }
}
impl AddAssign<UnitNanokaysers> for UnitNanokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitNanokaysers) {}
}
impl Sub<UnitNanokaysers> for UnitNanokaysers {
    type Output = UnitNanokaysers;
    #[inline]
    fn sub(self, _: UnitNanokaysers) -> Self::Output {
        UnitNanokaysers
    }
}
impl SubAssign<UnitNanokaysers> for UnitNanokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanokaysers) {}
}
pub struct UnitNanokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanokaysersMul {
    #[inline]
    fn clone(&self) -> UnitNanokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitNanokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanokaysersMul> for i8 {
    type Output = Quantity<i8, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for i16 {
    type Output = Quantity<i16, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for i32 {
    type Output = Quantity<i32, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for i64 {
    type Output = Quantity<i64, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for i128 {
    type Output = Quantity<i128, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for isize {
    type Output = Quantity<isize, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for u8 {
    type Output = Quantity<u8, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for u16 {
    type Output = Quantity<u16, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for u32 {
    type Output = Quantity<u32, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for u64 {
    type Output = Quantity<u64, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for u128 {
    type Output = Quantity<u128, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for usize {
    type Output = Quantity<usize, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for f32 {
    type Output = Quantity<f32, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
impl Mul<UnitNanokaysersMul> for f64 {
    type Output = Quantity<f64, UnitNanokaysers>;
    fn mul(self, _: UnitNanokaysersMul) -> Self::Output {
        Quantity::new(self, UnitNanokaysers)
    }
}
pub struct UnitPicokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokaysers {
    #[inline]
    fn clone(&self) -> UnitPicokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokaysers {
    #[inline]
    fn eq(&self, other: &UnitPicokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicokaysers {
    fn default() -> Self {
        UnitPicokaysers
    }
}
impl Add<UnitPicokaysers> for UnitPicokaysers {
    type Output = UnitPicokaysers;
    #[inline]
    fn add(self, _: UnitPicokaysers) -> Self::Output {
        UnitPicokaysers
    }
}
impl AddAssign<UnitPicokaysers> for UnitPicokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitPicokaysers) {}
}
impl Sub<UnitPicokaysers> for UnitPicokaysers {
    type Output = UnitPicokaysers;
    #[inline]
    fn sub(self, _: UnitPicokaysers) -> Self::Output {
        UnitPicokaysers
    }
}
impl SubAssign<UnitPicokaysers> for UnitPicokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicokaysers) {}
}
pub struct UnitPicokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicokaysersMul {
    #[inline]
    fn clone(&self) -> UnitPicokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitPicokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicokaysersMul> for i8 {
    type Output = Quantity<i8, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for i16 {
    type Output = Quantity<i16, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for i32 {
    type Output = Quantity<i32, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for i64 {
    type Output = Quantity<i64, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for i128 {
    type Output = Quantity<i128, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for isize {
    type Output = Quantity<isize, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for u8 {
    type Output = Quantity<u8, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for u16 {
    type Output = Quantity<u16, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for u32 {
    type Output = Quantity<u32, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for u64 {
    type Output = Quantity<u64, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for u128 {
    type Output = Quantity<u128, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for usize {
    type Output = Quantity<usize, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for f32 {
    type Output = Quantity<f32, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
impl Mul<UnitPicokaysersMul> for f64 {
    type Output = Quantity<f64, UnitPicokaysers>;
    fn mul(self, _: UnitPicokaysersMul) -> Self::Output {
        Quantity::new(self, UnitPicokaysers)
    }
}
pub struct UnitFemtokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokaysers {
    #[inline]
    fn clone(&self) -> UnitFemtokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokaysers {
    #[inline]
    fn eq(&self, other: &UnitFemtokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtokaysers {
    fn default() -> Self {
        UnitFemtokaysers
    }
}
impl Add<UnitFemtokaysers> for UnitFemtokaysers {
    type Output = UnitFemtokaysers;
    #[inline]
    fn add(self, _: UnitFemtokaysers) -> Self::Output {
        UnitFemtokaysers
    }
}
impl AddAssign<UnitFemtokaysers> for UnitFemtokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtokaysers) {}
}
impl Sub<UnitFemtokaysers> for UnitFemtokaysers {
    type Output = UnitFemtokaysers;
    #[inline]
    fn sub(self, _: UnitFemtokaysers) -> Self::Output {
        UnitFemtokaysers
    }
}
impl SubAssign<UnitFemtokaysers> for UnitFemtokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtokaysers) {}
}
pub struct UnitFemtokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtokaysersMul {
    #[inline]
    fn clone(&self) -> UnitFemtokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitFemtokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtokaysersMul> for i8 {
    type Output = Quantity<i8, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for i16 {
    type Output = Quantity<i16, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for i32 {
    type Output = Quantity<i32, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for i64 {
    type Output = Quantity<i64, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for i128 {
    type Output = Quantity<i128, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for isize {
    type Output = Quantity<isize, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for u8 {
    type Output = Quantity<u8, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for u16 {
    type Output = Quantity<u16, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for u32 {
    type Output = Quantity<u32, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for u64 {
    type Output = Quantity<u64, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for u128 {
    type Output = Quantity<u128, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for usize {
    type Output = Quantity<usize, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for f32 {
    type Output = Quantity<f32, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
impl Mul<UnitFemtokaysersMul> for f64 {
    type Output = Quantity<f64, UnitFemtokaysers>;
    fn mul(self, _: UnitFemtokaysersMul) -> Self::Output {
        Quantity::new(self, UnitFemtokaysers)
    }
}
pub struct UnitAttokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokaysers {
    #[inline]
    fn clone(&self) -> UnitAttokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokaysers {
    #[inline]
    fn eq(&self, other: &UnitAttokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttokaysers {
    fn default() -> Self {
        UnitAttokaysers
    }
}
impl Add<UnitAttokaysers> for UnitAttokaysers {
    type Output = UnitAttokaysers;
    #[inline]
    fn add(self, _: UnitAttokaysers) -> Self::Output {
        UnitAttokaysers
    }
}
impl AddAssign<UnitAttokaysers> for UnitAttokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitAttokaysers) {}
}
impl Sub<UnitAttokaysers> for UnitAttokaysers {
    type Output = UnitAttokaysers;
    #[inline]
    fn sub(self, _: UnitAttokaysers) -> Self::Output {
        UnitAttokaysers
    }
}
impl SubAssign<UnitAttokaysers> for UnitAttokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttokaysers) {}
}
pub struct UnitAttokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttokaysersMul {
    #[inline]
    fn clone(&self) -> UnitAttokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitAttokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttokaysersMul> for i8 {
    type Output = Quantity<i8, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for i16 {
    type Output = Quantity<i16, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for i32 {
    type Output = Quantity<i32, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for i64 {
    type Output = Quantity<i64, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for i128 {
    type Output = Quantity<i128, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for isize {
    type Output = Quantity<isize, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for u8 {
    type Output = Quantity<u8, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for u16 {
    type Output = Quantity<u16, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for u32 {
    type Output = Quantity<u32, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for u64 {
    type Output = Quantity<u64, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for u128 {
    type Output = Quantity<u128, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for usize {
    type Output = Quantity<usize, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for f32 {
    type Output = Quantity<f32, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
impl Mul<UnitAttokaysersMul> for f64 {
    type Output = Quantity<f64, UnitAttokaysers>;
    fn mul(self, _: UnitAttokaysersMul) -> Self::Output {
        Quantity::new(self, UnitAttokaysers)
    }
}
pub struct UnitZeptokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokaysers {
    #[inline]
    fn clone(&self) -> UnitZeptokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokaysers {
    #[inline]
    fn eq(&self, other: &UnitZeptokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptokaysers {
    fn default() -> Self {
        UnitZeptokaysers
    }
}
impl Add<UnitZeptokaysers> for UnitZeptokaysers {
    type Output = UnitZeptokaysers;
    #[inline]
    fn add(self, _: UnitZeptokaysers) -> Self::Output {
        UnitZeptokaysers
    }
}
impl AddAssign<UnitZeptokaysers> for UnitZeptokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptokaysers) {}
}
impl Sub<UnitZeptokaysers> for UnitZeptokaysers {
    type Output = UnitZeptokaysers;
    #[inline]
    fn sub(self, _: UnitZeptokaysers) -> Self::Output {
        UnitZeptokaysers
    }
}
impl SubAssign<UnitZeptokaysers> for UnitZeptokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptokaysers) {}
}
pub struct UnitZeptokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptokaysersMul {
    #[inline]
    fn clone(&self) -> UnitZeptokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitZeptokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptokaysersMul> for i8 {
    type Output = Quantity<i8, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for i16 {
    type Output = Quantity<i16, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for i32 {
    type Output = Quantity<i32, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for i64 {
    type Output = Quantity<i64, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for i128 {
    type Output = Quantity<i128, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for isize {
    type Output = Quantity<isize, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for u8 {
    type Output = Quantity<u8, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for u16 {
    type Output = Quantity<u16, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for u32 {
    type Output = Quantity<u32, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for u64 {
    type Output = Quantity<u64, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for u128 {
    type Output = Quantity<u128, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for usize {
    type Output = Quantity<usize, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for f32 {
    type Output = Quantity<f32, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
impl Mul<UnitZeptokaysersMul> for f64 {
    type Output = Quantity<f64, UnitZeptokaysers>;
    fn mul(self, _: UnitZeptokaysersMul) -> Self::Output {
        Quantity::new(self, UnitZeptokaysers)
    }
}
pub struct UnitYoctokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokaysers {
    #[inline]
    fn clone(&self) -> UnitYoctokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokaysers {
    #[inline]
    fn eq(&self, other: &UnitYoctokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctokaysers {
    fn default() -> Self {
        UnitYoctokaysers
    }
}
impl Add<UnitYoctokaysers> for UnitYoctokaysers {
    type Output = UnitYoctokaysers;
    #[inline]
    fn add(self, _: UnitYoctokaysers) -> Self::Output {
        UnitYoctokaysers
    }
}
impl AddAssign<UnitYoctokaysers> for UnitYoctokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctokaysers) {}
}
impl Sub<UnitYoctokaysers> for UnitYoctokaysers {
    type Output = UnitYoctokaysers;
    #[inline]
    fn sub(self, _: UnitYoctokaysers) -> Self::Output {
        UnitYoctokaysers
    }
}
impl SubAssign<UnitYoctokaysers> for UnitYoctokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctokaysers) {}
}
pub struct UnitYoctokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctokaysersMul {
    #[inline]
    fn clone(&self) -> UnitYoctokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitYoctokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctokaysersMul> for i8 {
    type Output = Quantity<i8, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for i16 {
    type Output = Quantity<i16, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for i32 {
    type Output = Quantity<i32, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for i64 {
    type Output = Quantity<i64, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for i128 {
    type Output = Quantity<i128, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for isize {
    type Output = Quantity<isize, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for u8 {
    type Output = Quantity<u8, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for u16 {
    type Output = Quantity<u16, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for u32 {
    type Output = Quantity<u32, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for u64 {
    type Output = Quantity<u64, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for u128 {
    type Output = Quantity<u128, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for usize {
    type Output = Quantity<usize, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for f32 {
    type Output = Quantity<f32, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
impl Mul<UnitYoctokaysersMul> for f64 {
    type Output = Quantity<f64, UnitYoctokaysers>;
    fn mul(self, _: UnitYoctokaysersMul) -> Self::Output {
        Quantity::new(self, UnitYoctokaysers)
    }
}
pub struct UnitRontokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokaysers {
    #[inline]
    fn clone(&self) -> UnitRontokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokaysers {
    #[inline]
    fn eq(&self, other: &UnitRontokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontokaysers {
    fn default() -> Self {
        UnitRontokaysers
    }
}
impl Add<UnitRontokaysers> for UnitRontokaysers {
    type Output = UnitRontokaysers;
    #[inline]
    fn add(self, _: UnitRontokaysers) -> Self::Output {
        UnitRontokaysers
    }
}
impl AddAssign<UnitRontokaysers> for UnitRontokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitRontokaysers) {}
}
impl Sub<UnitRontokaysers> for UnitRontokaysers {
    type Output = UnitRontokaysers;
    #[inline]
    fn sub(self, _: UnitRontokaysers) -> Self::Output {
        UnitRontokaysers
    }
}
impl SubAssign<UnitRontokaysers> for UnitRontokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontokaysers) {}
}
pub struct UnitRontokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontokaysersMul {
    #[inline]
    fn clone(&self) -> UnitRontokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitRontokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontokaysersMul> for i8 {
    type Output = Quantity<i8, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for i16 {
    type Output = Quantity<i16, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for i32 {
    type Output = Quantity<i32, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for i64 {
    type Output = Quantity<i64, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for i128 {
    type Output = Quantity<i128, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for isize {
    type Output = Quantity<isize, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for u8 {
    type Output = Quantity<u8, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for u16 {
    type Output = Quantity<u16, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for u32 {
    type Output = Quantity<u32, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for u64 {
    type Output = Quantity<u64, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for u128 {
    type Output = Quantity<u128, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for usize {
    type Output = Quantity<usize, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for f32 {
    type Output = Quantity<f32, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
impl Mul<UnitRontokaysersMul> for f64 {
    type Output = Quantity<f64, UnitRontokaysers>;
    fn mul(self, _: UnitRontokaysersMul) -> Self::Output {
        Quantity::new(self, UnitRontokaysers)
    }
}
pub struct UnitQuectokaysers;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokaysers {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokaysers")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokaysers {
    #[inline]
    fn clone(&self) -> UnitQuectokaysers {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokaysers {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokaysers {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokaysers {
    #[inline]
    fn eq(&self, other: &UnitQuectokaysers) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokaysers {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectokaysers {
    fn default() -> Self {
        UnitQuectokaysers
    }
}
impl Add<UnitQuectokaysers> for UnitQuectokaysers {
    type Output = UnitQuectokaysers;
    #[inline]
    fn add(self, _: UnitQuectokaysers) -> Self::Output {
        UnitQuectokaysers
    }
}
impl AddAssign<UnitQuectokaysers> for UnitQuectokaysers {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectokaysers) {}
}
impl Sub<UnitQuectokaysers> for UnitQuectokaysers {
    type Output = UnitQuectokaysers;
    #[inline]
    fn sub(self, _: UnitQuectokaysers) -> Self::Output {
        UnitQuectokaysers
    }
}
impl SubAssign<UnitQuectokaysers> for UnitQuectokaysers {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectokaysers) {}
}
pub struct UnitQuectokaysersMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectokaysersMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectokaysersMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectokaysersMul {
    #[inline]
    fn clone(&self) -> UnitQuectokaysersMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectokaysersMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectokaysersMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectokaysersMul {
    #[inline]
    fn eq(&self, other: &UnitQuectokaysersMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectokaysersMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectokaysersMul> for i8 {
    type Output = Quantity<i8, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for i16 {
    type Output = Quantity<i16, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for i32 {
    type Output = Quantity<i32, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for i64 {
    type Output = Quantity<i64, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for i128 {
    type Output = Quantity<i128, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for isize {
    type Output = Quantity<isize, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for u8 {
    type Output = Quantity<u8, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for u16 {
    type Output = Quantity<u16, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for u32 {
    type Output = Quantity<u32, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for u64 {
    type Output = Quantity<u64, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for u128 {
    type Output = Quantity<u128, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for usize {
    type Output = Quantity<usize, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for f32 {
    type Output = Quantity<f32, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
impl Mul<UnitQuectokaysersMul> for f64 {
    type Output = Quantity<f64, UnitQuectokaysers>;
    fn mul(self, _: UnitQuectokaysersMul) -> Self::Output {
        Quantity::new(self, UnitQuectokaysers)
    }
}
pub type Kaysers<T> = Quantity<T, UnitKaysers>;
#[allow(non_upper_case_globals)]
pub static Kaysers: UnitKaysersMul = UnitKaysersMul;
pub type Quettakaysers<T> = Quantity<T, UnitQuettakaysers>;
#[allow(non_upper_case_globals)]
pub static Quettakaysers: UnitQuettakaysersMul = UnitQuettakaysersMul;
pub type Ronnakaysers<T> = Quantity<T, UnitRonnakaysers>;
#[allow(non_upper_case_globals)]
pub static Ronnakaysers: UnitRonnakaysersMul = UnitRonnakaysersMul;
pub type Yottakaysers<T> = Quantity<T, UnitYottakaysers>;
#[allow(non_upper_case_globals)]
pub static Yottakaysers: UnitYottakaysersMul = UnitYottakaysersMul;
pub type Zettakaysers<T> = Quantity<T, UnitZettakaysers>;
#[allow(non_upper_case_globals)]
pub static Zettakaysers: UnitZettakaysersMul = UnitZettakaysersMul;
pub type Exakaysers<T> = Quantity<T, UnitExakaysers>;
#[allow(non_upper_case_globals)]
pub static Exakaysers: UnitExakaysersMul = UnitExakaysersMul;
pub type Petakaysers<T> = Quantity<T, UnitPetakaysers>;
#[allow(non_upper_case_globals)]
pub static Petakaysers: UnitPetakaysersMul = UnitPetakaysersMul;
pub type Terakaysers<T> = Quantity<T, UnitTerakaysers>;
#[allow(non_upper_case_globals)]
pub static Terakaysers: UnitTerakaysersMul = UnitTerakaysersMul;
pub type Gigakaysers<T> = Quantity<T, UnitGigakaysers>;
#[allow(non_upper_case_globals)]
pub static Gigakaysers: UnitGigakaysersMul = UnitGigakaysersMul;
pub type Megakaysers<T> = Quantity<T, UnitMegakaysers>;
#[allow(non_upper_case_globals)]
pub static Megakaysers: UnitMegakaysersMul = UnitMegakaysersMul;
pub type Kilokaysers<T> = Quantity<T, UnitKilokaysers>;
#[allow(non_upper_case_globals)]
pub static Kilokaysers: UnitKilokaysersMul = UnitKilokaysersMul;
pub type Hectokaysers<T> = Quantity<T, UnitHectokaysers>;
#[allow(non_upper_case_globals)]
pub static Hectokaysers: UnitHectokaysersMul = UnitHectokaysersMul;
pub type Decakaysers<T> = Quantity<T, UnitDecakaysers>;
#[allow(non_upper_case_globals)]
pub static Decakaysers: UnitDecakaysersMul = UnitDecakaysersMul;
pub type Decikaysers<T> = Quantity<T, UnitDecikaysers>;
#[allow(non_upper_case_globals)]
pub static Decikaysers: UnitDecikaysersMul = UnitDecikaysersMul;
pub type Centikaysers<T> = Quantity<T, UnitCentikaysers>;
#[allow(non_upper_case_globals)]
pub static Centikaysers: UnitCentikaysersMul = UnitCentikaysersMul;
pub type Millikaysers<T> = Quantity<T, UnitMillikaysers>;
#[allow(non_upper_case_globals)]
pub static Millikaysers: UnitMillikaysersMul = UnitMillikaysersMul;
pub type Microkaysers<T> = Quantity<T, UnitMicrokaysers>;
#[allow(non_upper_case_globals)]
pub static Microkaysers: UnitMicrokaysersMul = UnitMicrokaysersMul;
pub type Nanokaysers<T> = Quantity<T, UnitNanokaysers>;
#[allow(non_upper_case_globals)]
pub static Nanokaysers: UnitNanokaysersMul = UnitNanokaysersMul;
pub type Picokaysers<T> = Quantity<T, UnitPicokaysers>;
#[allow(non_upper_case_globals)]
pub static Picokaysers: UnitPicokaysersMul = UnitPicokaysersMul;
pub type Femtokaysers<T> = Quantity<T, UnitFemtokaysers>;
#[allow(non_upper_case_globals)]
pub static Femtokaysers: UnitFemtokaysersMul = UnitFemtokaysersMul;
pub type Attokaysers<T> = Quantity<T, UnitAttokaysers>;
#[allow(non_upper_case_globals)]
pub static Attokaysers: UnitAttokaysersMul = UnitAttokaysersMul;
pub type Zeptokaysers<T> = Quantity<T, UnitZeptokaysers>;
#[allow(non_upper_case_globals)]
pub static Zeptokaysers: UnitZeptokaysersMul = UnitZeptokaysersMul;
pub type Yoctokaysers<T> = Quantity<T, UnitYoctokaysers>;
#[allow(non_upper_case_globals)]
pub static Yoctokaysers: UnitYoctokaysersMul = UnitYoctokaysersMul;
pub type Rontokaysers<T> = Quantity<T, UnitRontokaysers>;
#[allow(non_upper_case_globals)]
pub static Rontokaysers: UnitRontokaysersMul = UnitRontokaysersMul;
pub type Quectokaysers<T> = Quantity<T, UnitQuectokaysers>;
#[allow(non_upper_case_globals)]
pub static Quectokaysers: UnitQuectokaysersMul = UnitQuectokaysersMul;
pub struct UnitGals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGals {
    #[inline]
    fn clone(&self) -> UnitGals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGals {
    #[inline]
    fn eq(&self, other: &UnitGals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGals {
    fn default() -> Self {
        UnitGals
    }
}
impl Add<UnitGals> for UnitGals {
    type Output = UnitGals;
    #[inline]
    fn add(self, _: UnitGals) -> Self::Output {
        UnitGals
    }
}
impl AddAssign<UnitGals> for UnitGals {
    #[inline]
    fn add_assign(&mut self, _: UnitGals) {}
}
impl Sub<UnitGals> for UnitGals {
    type Output = UnitGals;
    #[inline]
    fn sub(self, _: UnitGals) -> Self::Output {
        UnitGals
    }
}
impl SubAssign<UnitGals> for UnitGals {
    #[inline]
    fn sub_assign(&mut self, _: UnitGals) {}
}
pub struct UnitGalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGalsMul {
    #[inline]
    fn clone(&self) -> UnitGalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGalsMul {
    #[inline]
    fn eq(&self, other: &UnitGalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGalsMul> for i8 {
    type Output = Quantity<i8, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for i16 {
    type Output = Quantity<i16, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for i32 {
    type Output = Quantity<i32, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for i64 {
    type Output = Quantity<i64, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for i128 {
    type Output = Quantity<i128, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for isize {
    type Output = Quantity<isize, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for u8 {
    type Output = Quantity<u8, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for u16 {
    type Output = Quantity<u16, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for u32 {
    type Output = Quantity<u32, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for u64 {
    type Output = Quantity<u64, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for u128 {
    type Output = Quantity<u128, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for usize {
    type Output = Quantity<usize, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for f32 {
    type Output = Quantity<f32, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
impl Mul<UnitGalsMul> for f64 {
    type Output = Quantity<f64, UnitGals>;
    fn mul(self, _: UnitGalsMul) -> Self::Output {
        Quantity::new(self, UnitGals)
    }
}
pub struct UnitQuettagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagals {
    #[inline]
    fn clone(&self) -> UnitQuettagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagals {
    #[inline]
    fn eq(&self, other: &UnitQuettagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettagals {
    fn default() -> Self {
        UnitQuettagals
    }
}
impl Add<UnitQuettagals> for UnitQuettagals {
    type Output = UnitQuettagals;
    #[inline]
    fn add(self, _: UnitQuettagals) -> Self::Output {
        UnitQuettagals
    }
}
impl AddAssign<UnitQuettagals> for UnitQuettagals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettagals) {}
}
impl Sub<UnitQuettagals> for UnitQuettagals {
    type Output = UnitQuettagals;
    #[inline]
    fn sub(self, _: UnitQuettagals) -> Self::Output {
        UnitQuettagals
    }
}
impl SubAssign<UnitQuettagals> for UnitQuettagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettagals) {}
}
pub struct UnitQuettagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagalsMul {
    #[inline]
    fn clone(&self) -> UnitQuettagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettagalsMul> for i8 {
    type Output = Quantity<i8, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for i16 {
    type Output = Quantity<i16, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for i32 {
    type Output = Quantity<i32, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for i64 {
    type Output = Quantity<i64, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for i128 {
    type Output = Quantity<i128, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for isize {
    type Output = Quantity<isize, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for u8 {
    type Output = Quantity<u8, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for u16 {
    type Output = Quantity<u16, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for u32 {
    type Output = Quantity<u32, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for u64 {
    type Output = Quantity<u64, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for u128 {
    type Output = Quantity<u128, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for usize {
    type Output = Quantity<usize, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for f32 {
    type Output = Quantity<f32, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
impl Mul<UnitQuettagalsMul> for f64 {
    type Output = Quantity<f64, UnitQuettagals>;
    fn mul(self, _: UnitQuettagalsMul) -> Self::Output {
        Quantity::new(self, UnitQuettagals)
    }
}
pub struct UnitRonnagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagals {
    #[inline]
    fn clone(&self) -> UnitRonnagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagals {
    #[inline]
    fn eq(&self, other: &UnitRonnagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnagals {
    fn default() -> Self {
        UnitRonnagals
    }
}
impl Add<UnitRonnagals> for UnitRonnagals {
    type Output = UnitRonnagals;
    #[inline]
    fn add(self, _: UnitRonnagals) -> Self::Output {
        UnitRonnagals
    }
}
impl AddAssign<UnitRonnagals> for UnitRonnagals {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnagals) {}
}
impl Sub<UnitRonnagals> for UnitRonnagals {
    type Output = UnitRonnagals;
    #[inline]
    fn sub(self, _: UnitRonnagals) -> Self::Output {
        UnitRonnagals
    }
}
impl SubAssign<UnitRonnagals> for UnitRonnagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnagals) {}
}
pub struct UnitRonnagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagalsMul {
    #[inline]
    fn clone(&self) -> UnitRonnagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagalsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnagalsMul> for i8 {
    type Output = Quantity<i8, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for i16 {
    type Output = Quantity<i16, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for i32 {
    type Output = Quantity<i32, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for i64 {
    type Output = Quantity<i64, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for i128 {
    type Output = Quantity<i128, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for isize {
    type Output = Quantity<isize, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for u8 {
    type Output = Quantity<u8, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for u16 {
    type Output = Quantity<u16, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for u32 {
    type Output = Quantity<u32, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for u64 {
    type Output = Quantity<u64, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for u128 {
    type Output = Quantity<u128, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for usize {
    type Output = Quantity<usize, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for f32 {
    type Output = Quantity<f32, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
impl Mul<UnitRonnagalsMul> for f64 {
    type Output = Quantity<f64, UnitRonnagals>;
    fn mul(self, _: UnitRonnagalsMul) -> Self::Output {
        Quantity::new(self, UnitRonnagals)
    }
}
pub struct UnitYottagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagals {
    #[inline]
    fn clone(&self) -> UnitYottagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagals {
    #[inline]
    fn eq(&self, other: &UnitYottagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottagals {
    fn default() -> Self {
        UnitYottagals
    }
}
impl Add<UnitYottagals> for UnitYottagals {
    type Output = UnitYottagals;
    #[inline]
    fn add(self, _: UnitYottagals) -> Self::Output {
        UnitYottagals
    }
}
impl AddAssign<UnitYottagals> for UnitYottagals {
    #[inline]
    fn add_assign(&mut self, _: UnitYottagals) {}
}
impl Sub<UnitYottagals> for UnitYottagals {
    type Output = UnitYottagals;
    #[inline]
    fn sub(self, _: UnitYottagals) -> Self::Output {
        UnitYottagals
    }
}
impl SubAssign<UnitYottagals> for UnitYottagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottagals) {}
}
pub struct UnitYottagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagalsMul {
    #[inline]
    fn clone(&self) -> UnitYottagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagalsMul {
    #[inline]
    fn eq(&self, other: &UnitYottagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottagalsMul> for i8 {
    type Output = Quantity<i8, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for i16 {
    type Output = Quantity<i16, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for i32 {
    type Output = Quantity<i32, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for i64 {
    type Output = Quantity<i64, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for i128 {
    type Output = Quantity<i128, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for isize {
    type Output = Quantity<isize, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for u8 {
    type Output = Quantity<u8, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for u16 {
    type Output = Quantity<u16, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for u32 {
    type Output = Quantity<u32, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for u64 {
    type Output = Quantity<u64, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for u128 {
    type Output = Quantity<u128, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for usize {
    type Output = Quantity<usize, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for f32 {
    type Output = Quantity<f32, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
impl Mul<UnitYottagalsMul> for f64 {
    type Output = Quantity<f64, UnitYottagals>;
    fn mul(self, _: UnitYottagalsMul) -> Self::Output {
        Quantity::new(self, UnitYottagals)
    }
}
pub struct UnitZettagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagals {
    #[inline]
    fn clone(&self) -> UnitZettagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagals {
    #[inline]
    fn eq(&self, other: &UnitZettagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettagals {
    fn default() -> Self {
        UnitZettagals
    }
}
impl Add<UnitZettagals> for UnitZettagals {
    type Output = UnitZettagals;
    #[inline]
    fn add(self, _: UnitZettagals) -> Self::Output {
        UnitZettagals
    }
}
impl AddAssign<UnitZettagals> for UnitZettagals {
    #[inline]
    fn add_assign(&mut self, _: UnitZettagals) {}
}
impl Sub<UnitZettagals> for UnitZettagals {
    type Output = UnitZettagals;
    #[inline]
    fn sub(self, _: UnitZettagals) -> Self::Output {
        UnitZettagals
    }
}
impl SubAssign<UnitZettagals> for UnitZettagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettagals) {}
}
pub struct UnitZettagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagalsMul {
    #[inline]
    fn clone(&self) -> UnitZettagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagalsMul {
    #[inline]
    fn eq(&self, other: &UnitZettagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettagalsMul> for i8 {
    type Output = Quantity<i8, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for i16 {
    type Output = Quantity<i16, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for i32 {
    type Output = Quantity<i32, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for i64 {
    type Output = Quantity<i64, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for i128 {
    type Output = Quantity<i128, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for isize {
    type Output = Quantity<isize, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for u8 {
    type Output = Quantity<u8, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for u16 {
    type Output = Quantity<u16, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for u32 {
    type Output = Quantity<u32, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for u64 {
    type Output = Quantity<u64, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for u128 {
    type Output = Quantity<u128, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for usize {
    type Output = Quantity<usize, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for f32 {
    type Output = Quantity<f32, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
impl Mul<UnitZettagalsMul> for f64 {
    type Output = Quantity<f64, UnitZettagals>;
    fn mul(self, _: UnitZettagalsMul) -> Self::Output {
        Quantity::new(self, UnitZettagals)
    }
}
pub struct UnitExagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagals {
    #[inline]
    fn clone(&self) -> UnitExagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagals {
    #[inline]
    fn eq(&self, other: &UnitExagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExagals {
    fn default() -> Self {
        UnitExagals
    }
}
impl Add<UnitExagals> for UnitExagals {
    type Output = UnitExagals;
    #[inline]
    fn add(self, _: UnitExagals) -> Self::Output {
        UnitExagals
    }
}
impl AddAssign<UnitExagals> for UnitExagals {
    #[inline]
    fn add_assign(&mut self, _: UnitExagals) {}
}
impl Sub<UnitExagals> for UnitExagals {
    type Output = UnitExagals;
    #[inline]
    fn sub(self, _: UnitExagals) -> Self::Output {
        UnitExagals
    }
}
impl SubAssign<UnitExagals> for UnitExagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitExagals) {}
}
pub struct UnitExagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagalsMul {
    #[inline]
    fn clone(&self) -> UnitExagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagalsMul {
    #[inline]
    fn eq(&self, other: &UnitExagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExagalsMul> for i8 {
    type Output = Quantity<i8, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for i16 {
    type Output = Quantity<i16, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for i32 {
    type Output = Quantity<i32, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for i64 {
    type Output = Quantity<i64, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for i128 {
    type Output = Quantity<i128, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for isize {
    type Output = Quantity<isize, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for u8 {
    type Output = Quantity<u8, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for u16 {
    type Output = Quantity<u16, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for u32 {
    type Output = Quantity<u32, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for u64 {
    type Output = Quantity<u64, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for u128 {
    type Output = Quantity<u128, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for usize {
    type Output = Quantity<usize, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for f32 {
    type Output = Quantity<f32, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
impl Mul<UnitExagalsMul> for f64 {
    type Output = Quantity<f64, UnitExagals>;
    fn mul(self, _: UnitExagalsMul) -> Self::Output {
        Quantity::new(self, UnitExagals)
    }
}
pub struct UnitPetagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagals {
    #[inline]
    fn clone(&self) -> UnitPetagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagals {
    #[inline]
    fn eq(&self, other: &UnitPetagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetagals {
    fn default() -> Self {
        UnitPetagals
    }
}
impl Add<UnitPetagals> for UnitPetagals {
    type Output = UnitPetagals;
    #[inline]
    fn add(self, _: UnitPetagals) -> Self::Output {
        UnitPetagals
    }
}
impl AddAssign<UnitPetagals> for UnitPetagals {
    #[inline]
    fn add_assign(&mut self, _: UnitPetagals) {}
}
impl Sub<UnitPetagals> for UnitPetagals {
    type Output = UnitPetagals;
    #[inline]
    fn sub(self, _: UnitPetagals) -> Self::Output {
        UnitPetagals
    }
}
impl SubAssign<UnitPetagals> for UnitPetagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetagals) {}
}
pub struct UnitPetagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagalsMul {
    #[inline]
    fn clone(&self) -> UnitPetagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagalsMul {
    #[inline]
    fn eq(&self, other: &UnitPetagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetagalsMul> for i8 {
    type Output = Quantity<i8, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for i16 {
    type Output = Quantity<i16, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for i32 {
    type Output = Quantity<i32, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for i64 {
    type Output = Quantity<i64, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for i128 {
    type Output = Quantity<i128, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for isize {
    type Output = Quantity<isize, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for u8 {
    type Output = Quantity<u8, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for u16 {
    type Output = Quantity<u16, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for u32 {
    type Output = Quantity<u32, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for u64 {
    type Output = Quantity<u64, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for u128 {
    type Output = Quantity<u128, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for usize {
    type Output = Quantity<usize, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for f32 {
    type Output = Quantity<f32, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
impl Mul<UnitPetagalsMul> for f64 {
    type Output = Quantity<f64, UnitPetagals>;
    fn mul(self, _: UnitPetagalsMul) -> Self::Output {
        Quantity::new(self, UnitPetagals)
    }
}
pub struct UnitTeragals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragals {
    #[inline]
    fn clone(&self) -> UnitTeragals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragals {
    #[inline]
    fn eq(&self, other: &UnitTeragals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeragals {
    fn default() -> Self {
        UnitTeragals
    }
}
impl Add<UnitTeragals> for UnitTeragals {
    type Output = UnitTeragals;
    #[inline]
    fn add(self, _: UnitTeragals) -> Self::Output {
        UnitTeragals
    }
}
impl AddAssign<UnitTeragals> for UnitTeragals {
    #[inline]
    fn add_assign(&mut self, _: UnitTeragals) {}
}
impl Sub<UnitTeragals> for UnitTeragals {
    type Output = UnitTeragals;
    #[inline]
    fn sub(self, _: UnitTeragals) -> Self::Output {
        UnitTeragals
    }
}
impl SubAssign<UnitTeragals> for UnitTeragals {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeragals) {}
}
pub struct UnitTeragalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragalsMul {
    #[inline]
    fn clone(&self) -> UnitTeragalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragalsMul {
    #[inline]
    fn eq(&self, other: &UnitTeragalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeragalsMul> for i8 {
    type Output = Quantity<i8, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for i16 {
    type Output = Quantity<i16, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for i32 {
    type Output = Quantity<i32, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for i64 {
    type Output = Quantity<i64, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for i128 {
    type Output = Quantity<i128, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for isize {
    type Output = Quantity<isize, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for u8 {
    type Output = Quantity<u8, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for u16 {
    type Output = Quantity<u16, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for u32 {
    type Output = Quantity<u32, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for u64 {
    type Output = Quantity<u64, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for u128 {
    type Output = Quantity<u128, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for usize {
    type Output = Quantity<usize, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for f32 {
    type Output = Quantity<f32, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
impl Mul<UnitTeragalsMul> for f64 {
    type Output = Quantity<f64, UnitTeragals>;
    fn mul(self, _: UnitTeragalsMul) -> Self::Output {
        Quantity::new(self, UnitTeragals)
    }
}
pub struct UnitGigagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagals {
    #[inline]
    fn clone(&self) -> UnitGigagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagals {
    #[inline]
    fn eq(&self, other: &UnitGigagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigagals {
    fn default() -> Self {
        UnitGigagals
    }
}
impl Add<UnitGigagals> for UnitGigagals {
    type Output = UnitGigagals;
    #[inline]
    fn add(self, _: UnitGigagals) -> Self::Output {
        UnitGigagals
    }
}
impl AddAssign<UnitGigagals> for UnitGigagals {
    #[inline]
    fn add_assign(&mut self, _: UnitGigagals) {}
}
impl Sub<UnitGigagals> for UnitGigagals {
    type Output = UnitGigagals;
    #[inline]
    fn sub(self, _: UnitGigagals) -> Self::Output {
        UnitGigagals
    }
}
impl SubAssign<UnitGigagals> for UnitGigagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigagals) {}
}
pub struct UnitGigagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagalsMul {
    #[inline]
    fn clone(&self) -> UnitGigagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagalsMul {
    #[inline]
    fn eq(&self, other: &UnitGigagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigagalsMul> for i8 {
    type Output = Quantity<i8, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for i16 {
    type Output = Quantity<i16, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for i32 {
    type Output = Quantity<i32, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for i64 {
    type Output = Quantity<i64, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for i128 {
    type Output = Quantity<i128, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for isize {
    type Output = Quantity<isize, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for u8 {
    type Output = Quantity<u8, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for u16 {
    type Output = Quantity<u16, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for u32 {
    type Output = Quantity<u32, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for u64 {
    type Output = Quantity<u64, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for u128 {
    type Output = Quantity<u128, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for usize {
    type Output = Quantity<usize, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for f32 {
    type Output = Quantity<f32, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
impl Mul<UnitGigagalsMul> for f64 {
    type Output = Quantity<f64, UnitGigagals>;
    fn mul(self, _: UnitGigagalsMul) -> Self::Output {
        Quantity::new(self, UnitGigagals)
    }
}
pub struct UnitMegagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagals {
    #[inline]
    fn clone(&self) -> UnitMegagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagals {
    #[inline]
    fn eq(&self, other: &UnitMegagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegagals {
    fn default() -> Self {
        UnitMegagals
    }
}
impl Add<UnitMegagals> for UnitMegagals {
    type Output = UnitMegagals;
    #[inline]
    fn add(self, _: UnitMegagals) -> Self::Output {
        UnitMegagals
    }
}
impl AddAssign<UnitMegagals> for UnitMegagals {
    #[inline]
    fn add_assign(&mut self, _: UnitMegagals) {}
}
impl Sub<UnitMegagals> for UnitMegagals {
    type Output = UnitMegagals;
    #[inline]
    fn sub(self, _: UnitMegagals) -> Self::Output {
        UnitMegagals
    }
}
impl SubAssign<UnitMegagals> for UnitMegagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegagals) {}
}
pub struct UnitMegagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagalsMul {
    #[inline]
    fn clone(&self) -> UnitMegagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagalsMul {
    #[inline]
    fn eq(&self, other: &UnitMegagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegagalsMul> for i8 {
    type Output = Quantity<i8, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for i16 {
    type Output = Quantity<i16, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for i32 {
    type Output = Quantity<i32, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for i64 {
    type Output = Quantity<i64, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for i128 {
    type Output = Quantity<i128, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for isize {
    type Output = Quantity<isize, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for u8 {
    type Output = Quantity<u8, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for u16 {
    type Output = Quantity<u16, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for u32 {
    type Output = Quantity<u32, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for u64 {
    type Output = Quantity<u64, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for u128 {
    type Output = Quantity<u128, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for usize {
    type Output = Quantity<usize, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for f32 {
    type Output = Quantity<f32, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
impl Mul<UnitMegagalsMul> for f64 {
    type Output = Quantity<f64, UnitMegagals>;
    fn mul(self, _: UnitMegagalsMul) -> Self::Output {
        Quantity::new(self, UnitMegagals)
    }
}
pub struct UnitKilogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilogals {
    #[inline]
    fn clone(&self) -> UnitKilogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilogals {
    #[inline]
    fn eq(&self, other: &UnitKilogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilogals {
    fn default() -> Self {
        UnitKilogals
    }
}
impl Add<UnitKilogals> for UnitKilogals {
    type Output = UnitKilogals;
    #[inline]
    fn add(self, _: UnitKilogals) -> Self::Output {
        UnitKilogals
    }
}
impl AddAssign<UnitKilogals> for UnitKilogals {
    #[inline]
    fn add_assign(&mut self, _: UnitKilogals) {}
}
impl Sub<UnitKilogals> for UnitKilogals {
    type Output = UnitKilogals;
    #[inline]
    fn sub(self, _: UnitKilogals) -> Self::Output {
        UnitKilogals
    }
}
impl SubAssign<UnitKilogals> for UnitKilogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilogals) {}
}
pub struct UnitKilogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilogalsMul {
    #[inline]
    fn clone(&self) -> UnitKilogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilogalsMul {
    #[inline]
    fn eq(&self, other: &UnitKilogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilogalsMul> for i8 {
    type Output = Quantity<i8, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for i16 {
    type Output = Quantity<i16, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for i32 {
    type Output = Quantity<i32, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for i64 {
    type Output = Quantity<i64, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for i128 {
    type Output = Quantity<i128, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for isize {
    type Output = Quantity<isize, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for u8 {
    type Output = Quantity<u8, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for u16 {
    type Output = Quantity<u16, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for u32 {
    type Output = Quantity<u32, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for u64 {
    type Output = Quantity<u64, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for u128 {
    type Output = Quantity<u128, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for usize {
    type Output = Quantity<usize, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for f32 {
    type Output = Quantity<f32, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
impl Mul<UnitKilogalsMul> for f64 {
    type Output = Quantity<f64, UnitKilogals>;
    fn mul(self, _: UnitKilogalsMul) -> Self::Output {
        Quantity::new(self, UnitKilogals)
    }
}
pub struct UnitHectogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectogals {
    #[inline]
    fn clone(&self) -> UnitHectogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectogals {
    #[inline]
    fn eq(&self, other: &UnitHectogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectogals {
    fn default() -> Self {
        UnitHectogals
    }
}
impl Add<UnitHectogals> for UnitHectogals {
    type Output = UnitHectogals;
    #[inline]
    fn add(self, _: UnitHectogals) -> Self::Output {
        UnitHectogals
    }
}
impl AddAssign<UnitHectogals> for UnitHectogals {
    #[inline]
    fn add_assign(&mut self, _: UnitHectogals) {}
}
impl Sub<UnitHectogals> for UnitHectogals {
    type Output = UnitHectogals;
    #[inline]
    fn sub(self, _: UnitHectogals) -> Self::Output {
        UnitHectogals
    }
}
impl SubAssign<UnitHectogals> for UnitHectogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectogals) {}
}
pub struct UnitHectogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectogalsMul {
    #[inline]
    fn clone(&self) -> UnitHectogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectogalsMul {
    #[inline]
    fn eq(&self, other: &UnitHectogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectogalsMul> for i8 {
    type Output = Quantity<i8, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for i16 {
    type Output = Quantity<i16, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for i32 {
    type Output = Quantity<i32, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for i64 {
    type Output = Quantity<i64, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for i128 {
    type Output = Quantity<i128, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for isize {
    type Output = Quantity<isize, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for u8 {
    type Output = Quantity<u8, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for u16 {
    type Output = Quantity<u16, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for u32 {
    type Output = Quantity<u32, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for u64 {
    type Output = Quantity<u64, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for u128 {
    type Output = Quantity<u128, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for usize {
    type Output = Quantity<usize, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for f32 {
    type Output = Quantity<f32, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
impl Mul<UnitHectogalsMul> for f64 {
    type Output = Quantity<f64, UnitHectogals>;
    fn mul(self, _: UnitHectogalsMul) -> Self::Output {
        Quantity::new(self, UnitHectogals)
    }
}
pub struct UnitDecagals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagals {
    #[inline]
    fn clone(&self) -> UnitDecagals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagals {
    #[inline]
    fn eq(&self, other: &UnitDecagals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecagals {
    fn default() -> Self {
        UnitDecagals
    }
}
impl Add<UnitDecagals> for UnitDecagals {
    type Output = UnitDecagals;
    #[inline]
    fn add(self, _: UnitDecagals) -> Self::Output {
        UnitDecagals
    }
}
impl AddAssign<UnitDecagals> for UnitDecagals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecagals) {}
}
impl Sub<UnitDecagals> for UnitDecagals {
    type Output = UnitDecagals;
    #[inline]
    fn sub(self, _: UnitDecagals) -> Self::Output {
        UnitDecagals
    }
}
impl SubAssign<UnitDecagals> for UnitDecagals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecagals) {}
}
pub struct UnitDecagalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagalsMul {
    #[inline]
    fn clone(&self) -> UnitDecagalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecagalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecagalsMul> for i8 {
    type Output = Quantity<i8, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for i16 {
    type Output = Quantity<i16, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for i32 {
    type Output = Quantity<i32, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for i64 {
    type Output = Quantity<i64, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for i128 {
    type Output = Quantity<i128, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for isize {
    type Output = Quantity<isize, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for u8 {
    type Output = Quantity<u8, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for u16 {
    type Output = Quantity<u16, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for u32 {
    type Output = Quantity<u32, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for u64 {
    type Output = Quantity<u64, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for u128 {
    type Output = Quantity<u128, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for usize {
    type Output = Quantity<usize, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for f32 {
    type Output = Quantity<f32, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
impl Mul<UnitDecagalsMul> for f64 {
    type Output = Quantity<f64, UnitDecagals>;
    fn mul(self, _: UnitDecagalsMul) -> Self::Output {
        Quantity::new(self, UnitDecagals)
    }
}
pub struct UnitDecigals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigals {
    #[inline]
    fn clone(&self) -> UnitDecigals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigals {
    #[inline]
    fn eq(&self, other: &UnitDecigals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecigals {
    fn default() -> Self {
        UnitDecigals
    }
}
impl Add<UnitDecigals> for UnitDecigals {
    type Output = UnitDecigals;
    #[inline]
    fn add(self, _: UnitDecigals) -> Self::Output {
        UnitDecigals
    }
}
impl AddAssign<UnitDecigals> for UnitDecigals {
    #[inline]
    fn add_assign(&mut self, _: UnitDecigals) {}
}
impl Sub<UnitDecigals> for UnitDecigals {
    type Output = UnitDecigals;
    #[inline]
    fn sub(self, _: UnitDecigals) -> Self::Output {
        UnitDecigals
    }
}
impl SubAssign<UnitDecigals> for UnitDecigals {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecigals) {}
}
pub struct UnitDecigalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigalsMul {
    #[inline]
    fn clone(&self) -> UnitDecigalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigalsMul {
    #[inline]
    fn eq(&self, other: &UnitDecigalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecigalsMul> for i8 {
    type Output = Quantity<i8, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for i16 {
    type Output = Quantity<i16, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for i32 {
    type Output = Quantity<i32, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for i64 {
    type Output = Quantity<i64, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for i128 {
    type Output = Quantity<i128, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for isize {
    type Output = Quantity<isize, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for u8 {
    type Output = Quantity<u8, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for u16 {
    type Output = Quantity<u16, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for u32 {
    type Output = Quantity<u32, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for u64 {
    type Output = Quantity<u64, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for u128 {
    type Output = Quantity<u128, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for usize {
    type Output = Quantity<usize, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for f32 {
    type Output = Quantity<f32, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
impl Mul<UnitDecigalsMul> for f64 {
    type Output = Quantity<f64, UnitDecigals>;
    fn mul(self, _: UnitDecigalsMul) -> Self::Output {
        Quantity::new(self, UnitDecigals)
    }
}
pub struct UnitCentigals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigals {
    #[inline]
    fn clone(&self) -> UnitCentigals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigals {
    #[inline]
    fn eq(&self, other: &UnitCentigals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentigals {
    fn default() -> Self {
        UnitCentigals
    }
}
impl Add<UnitCentigals> for UnitCentigals {
    type Output = UnitCentigals;
    #[inline]
    fn add(self, _: UnitCentigals) -> Self::Output {
        UnitCentigals
    }
}
impl AddAssign<UnitCentigals> for UnitCentigals {
    #[inline]
    fn add_assign(&mut self, _: UnitCentigals) {}
}
impl Sub<UnitCentigals> for UnitCentigals {
    type Output = UnitCentigals;
    #[inline]
    fn sub(self, _: UnitCentigals) -> Self::Output {
        UnitCentigals
    }
}
impl SubAssign<UnitCentigals> for UnitCentigals {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentigals) {}
}
pub struct UnitCentigalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigalsMul {
    #[inline]
    fn clone(&self) -> UnitCentigalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigalsMul {
    #[inline]
    fn eq(&self, other: &UnitCentigalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentigalsMul> for i8 {
    type Output = Quantity<i8, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for i16 {
    type Output = Quantity<i16, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for i32 {
    type Output = Quantity<i32, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for i64 {
    type Output = Quantity<i64, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for i128 {
    type Output = Quantity<i128, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for isize {
    type Output = Quantity<isize, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for u8 {
    type Output = Quantity<u8, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for u16 {
    type Output = Quantity<u16, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for u32 {
    type Output = Quantity<u32, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for u64 {
    type Output = Quantity<u64, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for u128 {
    type Output = Quantity<u128, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for usize {
    type Output = Quantity<usize, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for f32 {
    type Output = Quantity<f32, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
impl Mul<UnitCentigalsMul> for f64 {
    type Output = Quantity<f64, UnitCentigals>;
    fn mul(self, _: UnitCentigalsMul) -> Self::Output {
        Quantity::new(self, UnitCentigals)
    }
}
pub struct UnitMilligals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligals {
    #[inline]
    fn clone(&self) -> UnitMilligals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligals {
    #[inline]
    fn eq(&self, other: &UnitMilligals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilligals {
    fn default() -> Self {
        UnitMilligals
    }
}
impl Add<UnitMilligals> for UnitMilligals {
    type Output = UnitMilligals;
    #[inline]
    fn add(self, _: UnitMilligals) -> Self::Output {
        UnitMilligals
    }
}
impl AddAssign<UnitMilligals> for UnitMilligals {
    #[inline]
    fn add_assign(&mut self, _: UnitMilligals) {}
}
impl Sub<UnitMilligals> for UnitMilligals {
    type Output = UnitMilligals;
    #[inline]
    fn sub(self, _: UnitMilligals) -> Self::Output {
        UnitMilligals
    }
}
impl SubAssign<UnitMilligals> for UnitMilligals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilligals) {}
}
pub struct UnitMilligalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligalsMul {
    #[inline]
    fn clone(&self) -> UnitMilligalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligalsMul {
    #[inline]
    fn eq(&self, other: &UnitMilligalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilligalsMul> for i8 {
    type Output = Quantity<i8, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for i16 {
    type Output = Quantity<i16, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for i32 {
    type Output = Quantity<i32, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for i64 {
    type Output = Quantity<i64, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for i128 {
    type Output = Quantity<i128, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for isize {
    type Output = Quantity<isize, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for u8 {
    type Output = Quantity<u8, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for u16 {
    type Output = Quantity<u16, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for u32 {
    type Output = Quantity<u32, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for u64 {
    type Output = Quantity<u64, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for u128 {
    type Output = Quantity<u128, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for usize {
    type Output = Quantity<usize, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for f32 {
    type Output = Quantity<f32, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
impl Mul<UnitMilligalsMul> for f64 {
    type Output = Quantity<f64, UnitMilligals>;
    fn mul(self, _: UnitMilligalsMul) -> Self::Output {
        Quantity::new(self, UnitMilligals)
    }
}
pub struct UnitMicrogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrogals {
    #[inline]
    fn clone(&self) -> UnitMicrogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrogals {
    #[inline]
    fn eq(&self, other: &UnitMicrogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrogals {
    fn default() -> Self {
        UnitMicrogals
    }
}
impl Add<UnitMicrogals> for UnitMicrogals {
    type Output = UnitMicrogals;
    #[inline]
    fn add(self, _: UnitMicrogals) -> Self::Output {
        UnitMicrogals
    }
}
impl AddAssign<UnitMicrogals> for UnitMicrogals {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrogals) {}
}
impl Sub<UnitMicrogals> for UnitMicrogals {
    type Output = UnitMicrogals;
    #[inline]
    fn sub(self, _: UnitMicrogals) -> Self::Output {
        UnitMicrogals
    }
}
impl SubAssign<UnitMicrogals> for UnitMicrogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrogals) {}
}
pub struct UnitMicrogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrogalsMul {
    #[inline]
    fn clone(&self) -> UnitMicrogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrogalsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrogalsMul> for i8 {
    type Output = Quantity<i8, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for i16 {
    type Output = Quantity<i16, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for i32 {
    type Output = Quantity<i32, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for i64 {
    type Output = Quantity<i64, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for i128 {
    type Output = Quantity<i128, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for isize {
    type Output = Quantity<isize, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for u8 {
    type Output = Quantity<u8, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for u16 {
    type Output = Quantity<u16, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for u32 {
    type Output = Quantity<u32, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for u64 {
    type Output = Quantity<u64, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for u128 {
    type Output = Quantity<u128, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for usize {
    type Output = Quantity<usize, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for f32 {
    type Output = Quantity<f32, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
impl Mul<UnitMicrogalsMul> for f64 {
    type Output = Quantity<f64, UnitMicrogals>;
    fn mul(self, _: UnitMicrogalsMul) -> Self::Output {
        Quantity::new(self, UnitMicrogals)
    }
}
pub struct UnitNanogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanogals {
    #[inline]
    fn clone(&self) -> UnitNanogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanogals {
    #[inline]
    fn eq(&self, other: &UnitNanogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanogals {
    fn default() -> Self {
        UnitNanogals
    }
}
impl Add<UnitNanogals> for UnitNanogals {
    type Output = UnitNanogals;
    #[inline]
    fn add(self, _: UnitNanogals) -> Self::Output {
        UnitNanogals
    }
}
impl AddAssign<UnitNanogals> for UnitNanogals {
    #[inline]
    fn add_assign(&mut self, _: UnitNanogals) {}
}
impl Sub<UnitNanogals> for UnitNanogals {
    type Output = UnitNanogals;
    #[inline]
    fn sub(self, _: UnitNanogals) -> Self::Output {
        UnitNanogals
    }
}
impl SubAssign<UnitNanogals> for UnitNanogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanogals) {}
}
pub struct UnitNanogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanogalsMul {
    #[inline]
    fn clone(&self) -> UnitNanogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanogalsMul {
    #[inline]
    fn eq(&self, other: &UnitNanogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanogalsMul> for i8 {
    type Output = Quantity<i8, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for i16 {
    type Output = Quantity<i16, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for i32 {
    type Output = Quantity<i32, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for i64 {
    type Output = Quantity<i64, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for i128 {
    type Output = Quantity<i128, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for isize {
    type Output = Quantity<isize, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for u8 {
    type Output = Quantity<u8, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for u16 {
    type Output = Quantity<u16, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for u32 {
    type Output = Quantity<u32, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for u64 {
    type Output = Quantity<u64, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for u128 {
    type Output = Quantity<u128, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for usize {
    type Output = Quantity<usize, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for f32 {
    type Output = Quantity<f32, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
impl Mul<UnitNanogalsMul> for f64 {
    type Output = Quantity<f64, UnitNanogals>;
    fn mul(self, _: UnitNanogalsMul) -> Self::Output {
        Quantity::new(self, UnitNanogals)
    }
}
pub struct UnitPicogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicogals {
    #[inline]
    fn clone(&self) -> UnitPicogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicogals {
    #[inline]
    fn eq(&self, other: &UnitPicogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicogals {
    fn default() -> Self {
        UnitPicogals
    }
}
impl Add<UnitPicogals> for UnitPicogals {
    type Output = UnitPicogals;
    #[inline]
    fn add(self, _: UnitPicogals) -> Self::Output {
        UnitPicogals
    }
}
impl AddAssign<UnitPicogals> for UnitPicogals {
    #[inline]
    fn add_assign(&mut self, _: UnitPicogals) {}
}
impl Sub<UnitPicogals> for UnitPicogals {
    type Output = UnitPicogals;
    #[inline]
    fn sub(self, _: UnitPicogals) -> Self::Output {
        UnitPicogals
    }
}
impl SubAssign<UnitPicogals> for UnitPicogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicogals) {}
}
pub struct UnitPicogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicogalsMul {
    #[inline]
    fn clone(&self) -> UnitPicogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicogalsMul {
    #[inline]
    fn eq(&self, other: &UnitPicogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicogalsMul> for i8 {
    type Output = Quantity<i8, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for i16 {
    type Output = Quantity<i16, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for i32 {
    type Output = Quantity<i32, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for i64 {
    type Output = Quantity<i64, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for i128 {
    type Output = Quantity<i128, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for isize {
    type Output = Quantity<isize, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for u8 {
    type Output = Quantity<u8, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for u16 {
    type Output = Quantity<u16, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for u32 {
    type Output = Quantity<u32, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for u64 {
    type Output = Quantity<u64, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for u128 {
    type Output = Quantity<u128, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for usize {
    type Output = Quantity<usize, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for f32 {
    type Output = Quantity<f32, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
impl Mul<UnitPicogalsMul> for f64 {
    type Output = Quantity<f64, UnitPicogals>;
    fn mul(self, _: UnitPicogalsMul) -> Self::Output {
        Quantity::new(self, UnitPicogals)
    }
}
pub struct UnitFemtogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtogals {
    #[inline]
    fn clone(&self) -> UnitFemtogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtogals {
    #[inline]
    fn eq(&self, other: &UnitFemtogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtogals {
    fn default() -> Self {
        UnitFemtogals
    }
}
impl Add<UnitFemtogals> for UnitFemtogals {
    type Output = UnitFemtogals;
    #[inline]
    fn add(self, _: UnitFemtogals) -> Self::Output {
        UnitFemtogals
    }
}
impl AddAssign<UnitFemtogals> for UnitFemtogals {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtogals) {}
}
impl Sub<UnitFemtogals> for UnitFemtogals {
    type Output = UnitFemtogals;
    #[inline]
    fn sub(self, _: UnitFemtogals) -> Self::Output {
        UnitFemtogals
    }
}
impl SubAssign<UnitFemtogals> for UnitFemtogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtogals) {}
}
pub struct UnitFemtogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtogalsMul {
    #[inline]
    fn clone(&self) -> UnitFemtogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtogalsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtogalsMul> for i8 {
    type Output = Quantity<i8, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for i16 {
    type Output = Quantity<i16, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for i32 {
    type Output = Quantity<i32, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for i64 {
    type Output = Quantity<i64, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for i128 {
    type Output = Quantity<i128, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for isize {
    type Output = Quantity<isize, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for u8 {
    type Output = Quantity<u8, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for u16 {
    type Output = Quantity<u16, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for u32 {
    type Output = Quantity<u32, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for u64 {
    type Output = Quantity<u64, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for u128 {
    type Output = Quantity<u128, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for usize {
    type Output = Quantity<usize, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for f32 {
    type Output = Quantity<f32, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
impl Mul<UnitFemtogalsMul> for f64 {
    type Output = Quantity<f64, UnitFemtogals>;
    fn mul(self, _: UnitFemtogalsMul) -> Self::Output {
        Quantity::new(self, UnitFemtogals)
    }
}
pub struct UnitAttogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttogals {
    #[inline]
    fn clone(&self) -> UnitAttogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttogals {
    #[inline]
    fn eq(&self, other: &UnitAttogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttogals {
    fn default() -> Self {
        UnitAttogals
    }
}
impl Add<UnitAttogals> for UnitAttogals {
    type Output = UnitAttogals;
    #[inline]
    fn add(self, _: UnitAttogals) -> Self::Output {
        UnitAttogals
    }
}
impl AddAssign<UnitAttogals> for UnitAttogals {
    #[inline]
    fn add_assign(&mut self, _: UnitAttogals) {}
}
impl Sub<UnitAttogals> for UnitAttogals {
    type Output = UnitAttogals;
    #[inline]
    fn sub(self, _: UnitAttogals) -> Self::Output {
        UnitAttogals
    }
}
impl SubAssign<UnitAttogals> for UnitAttogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttogals) {}
}
pub struct UnitAttogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttogalsMul {
    #[inline]
    fn clone(&self) -> UnitAttogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttogalsMul {
    #[inline]
    fn eq(&self, other: &UnitAttogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttogalsMul> for i8 {
    type Output = Quantity<i8, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for i16 {
    type Output = Quantity<i16, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for i32 {
    type Output = Quantity<i32, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for i64 {
    type Output = Quantity<i64, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for i128 {
    type Output = Quantity<i128, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for isize {
    type Output = Quantity<isize, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for u8 {
    type Output = Quantity<u8, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for u16 {
    type Output = Quantity<u16, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for u32 {
    type Output = Quantity<u32, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for u64 {
    type Output = Quantity<u64, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for u128 {
    type Output = Quantity<u128, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for usize {
    type Output = Quantity<usize, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for f32 {
    type Output = Quantity<f32, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
impl Mul<UnitAttogalsMul> for f64 {
    type Output = Quantity<f64, UnitAttogals>;
    fn mul(self, _: UnitAttogalsMul) -> Self::Output {
        Quantity::new(self, UnitAttogals)
    }
}
pub struct UnitZeptogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptogals {
    #[inline]
    fn clone(&self) -> UnitZeptogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptogals {
    #[inline]
    fn eq(&self, other: &UnitZeptogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptogals {
    fn default() -> Self {
        UnitZeptogals
    }
}
impl Add<UnitZeptogals> for UnitZeptogals {
    type Output = UnitZeptogals;
    #[inline]
    fn add(self, _: UnitZeptogals) -> Self::Output {
        UnitZeptogals
    }
}
impl AddAssign<UnitZeptogals> for UnitZeptogals {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptogals) {}
}
impl Sub<UnitZeptogals> for UnitZeptogals {
    type Output = UnitZeptogals;
    #[inline]
    fn sub(self, _: UnitZeptogals) -> Self::Output {
        UnitZeptogals
    }
}
impl SubAssign<UnitZeptogals> for UnitZeptogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptogals) {}
}
pub struct UnitZeptogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptogalsMul {
    #[inline]
    fn clone(&self) -> UnitZeptogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptogalsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptogalsMul> for i8 {
    type Output = Quantity<i8, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for i16 {
    type Output = Quantity<i16, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for i32 {
    type Output = Quantity<i32, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for i64 {
    type Output = Quantity<i64, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for i128 {
    type Output = Quantity<i128, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for isize {
    type Output = Quantity<isize, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for u8 {
    type Output = Quantity<u8, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for u16 {
    type Output = Quantity<u16, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for u32 {
    type Output = Quantity<u32, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for u64 {
    type Output = Quantity<u64, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for u128 {
    type Output = Quantity<u128, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for usize {
    type Output = Quantity<usize, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for f32 {
    type Output = Quantity<f32, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
impl Mul<UnitZeptogalsMul> for f64 {
    type Output = Quantity<f64, UnitZeptogals>;
    fn mul(self, _: UnitZeptogalsMul) -> Self::Output {
        Quantity::new(self, UnitZeptogals)
    }
}
pub struct UnitYoctogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctogals {
    #[inline]
    fn clone(&self) -> UnitYoctogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctogals {
    #[inline]
    fn eq(&self, other: &UnitYoctogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctogals {
    fn default() -> Self {
        UnitYoctogals
    }
}
impl Add<UnitYoctogals> for UnitYoctogals {
    type Output = UnitYoctogals;
    #[inline]
    fn add(self, _: UnitYoctogals) -> Self::Output {
        UnitYoctogals
    }
}
impl AddAssign<UnitYoctogals> for UnitYoctogals {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctogals) {}
}
impl Sub<UnitYoctogals> for UnitYoctogals {
    type Output = UnitYoctogals;
    #[inline]
    fn sub(self, _: UnitYoctogals) -> Self::Output {
        UnitYoctogals
    }
}
impl SubAssign<UnitYoctogals> for UnitYoctogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctogals) {}
}
pub struct UnitYoctogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctogalsMul {
    #[inline]
    fn clone(&self) -> UnitYoctogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctogalsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctogalsMul> for i8 {
    type Output = Quantity<i8, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for i16 {
    type Output = Quantity<i16, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for i32 {
    type Output = Quantity<i32, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for i64 {
    type Output = Quantity<i64, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for i128 {
    type Output = Quantity<i128, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for isize {
    type Output = Quantity<isize, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for u8 {
    type Output = Quantity<u8, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for u16 {
    type Output = Quantity<u16, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for u32 {
    type Output = Quantity<u32, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for u64 {
    type Output = Quantity<u64, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for u128 {
    type Output = Quantity<u128, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for usize {
    type Output = Quantity<usize, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for f32 {
    type Output = Quantity<f32, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
impl Mul<UnitYoctogalsMul> for f64 {
    type Output = Quantity<f64, UnitYoctogals>;
    fn mul(self, _: UnitYoctogalsMul) -> Self::Output {
        Quantity::new(self, UnitYoctogals)
    }
}
pub struct UnitRontogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontogals {
    #[inline]
    fn clone(&self) -> UnitRontogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontogals {
    #[inline]
    fn eq(&self, other: &UnitRontogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontogals {
    fn default() -> Self {
        UnitRontogals
    }
}
impl Add<UnitRontogals> for UnitRontogals {
    type Output = UnitRontogals;
    #[inline]
    fn add(self, _: UnitRontogals) -> Self::Output {
        UnitRontogals
    }
}
impl AddAssign<UnitRontogals> for UnitRontogals {
    #[inline]
    fn add_assign(&mut self, _: UnitRontogals) {}
}
impl Sub<UnitRontogals> for UnitRontogals {
    type Output = UnitRontogals;
    #[inline]
    fn sub(self, _: UnitRontogals) -> Self::Output {
        UnitRontogals
    }
}
impl SubAssign<UnitRontogals> for UnitRontogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontogals) {}
}
pub struct UnitRontogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontogalsMul {
    #[inline]
    fn clone(&self) -> UnitRontogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontogalsMul {
    #[inline]
    fn eq(&self, other: &UnitRontogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontogalsMul> for i8 {
    type Output = Quantity<i8, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for i16 {
    type Output = Quantity<i16, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for i32 {
    type Output = Quantity<i32, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for i64 {
    type Output = Quantity<i64, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for i128 {
    type Output = Quantity<i128, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for isize {
    type Output = Quantity<isize, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for u8 {
    type Output = Quantity<u8, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for u16 {
    type Output = Quantity<u16, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for u32 {
    type Output = Quantity<u32, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for u64 {
    type Output = Quantity<u64, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for u128 {
    type Output = Quantity<u128, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for usize {
    type Output = Quantity<usize, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for f32 {
    type Output = Quantity<f32, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
impl Mul<UnitRontogalsMul> for f64 {
    type Output = Quantity<f64, UnitRontogals>;
    fn mul(self, _: UnitRontogalsMul) -> Self::Output {
        Quantity::new(self, UnitRontogals)
    }
}
pub struct UnitQuectogals;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectogals {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectogals")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectogals {
    #[inline]
    fn clone(&self) -> UnitQuectogals {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectogals {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectogals {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectogals {
    #[inline]
    fn eq(&self, other: &UnitQuectogals) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectogals {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectogals {
    fn default() -> Self {
        UnitQuectogals
    }
}
impl Add<UnitQuectogals> for UnitQuectogals {
    type Output = UnitQuectogals;
    #[inline]
    fn add(self, _: UnitQuectogals) -> Self::Output {
        UnitQuectogals
    }
}
impl AddAssign<UnitQuectogals> for UnitQuectogals {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectogals) {}
}
impl Sub<UnitQuectogals> for UnitQuectogals {
    type Output = UnitQuectogals;
    #[inline]
    fn sub(self, _: UnitQuectogals) -> Self::Output {
        UnitQuectogals
    }
}
impl SubAssign<UnitQuectogals> for UnitQuectogals {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectogals) {}
}
pub struct UnitQuectogalsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectogalsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectogalsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectogalsMul {
    #[inline]
    fn clone(&self) -> UnitQuectogalsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectogalsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectogalsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectogalsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectogalsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectogalsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectogalsMul> for i8 {
    type Output = Quantity<i8, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for i16 {
    type Output = Quantity<i16, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for i32 {
    type Output = Quantity<i32, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for i64 {
    type Output = Quantity<i64, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for i128 {
    type Output = Quantity<i128, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for isize {
    type Output = Quantity<isize, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for u8 {
    type Output = Quantity<u8, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for u16 {
    type Output = Quantity<u16, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for u32 {
    type Output = Quantity<u32, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for u64 {
    type Output = Quantity<u64, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for u128 {
    type Output = Quantity<u128, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for usize {
    type Output = Quantity<usize, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for f32 {
    type Output = Quantity<f32, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
impl Mul<UnitQuectogalsMul> for f64 {
    type Output = Quantity<f64, UnitQuectogals>;
    fn mul(self, _: UnitQuectogalsMul) -> Self::Output {
        Quantity::new(self, UnitQuectogals)
    }
}
pub type Gals<T> = Quantity<T, UnitGals>;
#[allow(non_upper_case_globals)]
pub static Gals: UnitGalsMul = UnitGalsMul;
pub type Quettagals<T> = Quantity<T, UnitQuettagals>;
#[allow(non_upper_case_globals)]
pub static Quettagals: UnitQuettagalsMul = UnitQuettagalsMul;
pub type Ronnagals<T> = Quantity<T, UnitRonnagals>;
#[allow(non_upper_case_globals)]
pub static Ronnagals: UnitRonnagalsMul = UnitRonnagalsMul;
pub type Yottagals<T> = Quantity<T, UnitYottagals>;
#[allow(non_upper_case_globals)]
pub static Yottagals: UnitYottagalsMul = UnitYottagalsMul;
pub type Zettagals<T> = Quantity<T, UnitZettagals>;
#[allow(non_upper_case_globals)]
pub static Zettagals: UnitZettagalsMul = UnitZettagalsMul;
pub type Exagals<T> = Quantity<T, UnitExagals>;
#[allow(non_upper_case_globals)]
pub static Exagals: UnitExagalsMul = UnitExagalsMul;
pub type Petagals<T> = Quantity<T, UnitPetagals>;
#[allow(non_upper_case_globals)]
pub static Petagals: UnitPetagalsMul = UnitPetagalsMul;
pub type Teragals<T> = Quantity<T, UnitTeragals>;
#[allow(non_upper_case_globals)]
pub static Teragals: UnitTeragalsMul = UnitTeragalsMul;
pub type Gigagals<T> = Quantity<T, UnitGigagals>;
#[allow(non_upper_case_globals)]
pub static Gigagals: UnitGigagalsMul = UnitGigagalsMul;
pub type Megagals<T> = Quantity<T, UnitMegagals>;
#[allow(non_upper_case_globals)]
pub static Megagals: UnitMegagalsMul = UnitMegagalsMul;
pub type Kilogals<T> = Quantity<T, UnitKilogals>;
#[allow(non_upper_case_globals)]
pub static Kilogals: UnitKilogalsMul = UnitKilogalsMul;
pub type Hectogals<T> = Quantity<T, UnitHectogals>;
#[allow(non_upper_case_globals)]
pub static Hectogals: UnitHectogalsMul = UnitHectogalsMul;
pub type Decagals<T> = Quantity<T, UnitDecagals>;
#[allow(non_upper_case_globals)]
pub static Decagals: UnitDecagalsMul = UnitDecagalsMul;
pub type Decigals<T> = Quantity<T, UnitDecigals>;
#[allow(non_upper_case_globals)]
pub static Decigals: UnitDecigalsMul = UnitDecigalsMul;
pub type Centigals<T> = Quantity<T, UnitCentigals>;
#[allow(non_upper_case_globals)]
pub static Centigals: UnitCentigalsMul = UnitCentigalsMul;
pub type Milligals<T> = Quantity<T, UnitMilligals>;
#[allow(non_upper_case_globals)]
pub static Milligals: UnitMilligalsMul = UnitMilligalsMul;
pub type Microgals<T> = Quantity<T, UnitMicrogals>;
#[allow(non_upper_case_globals)]
pub static Microgals: UnitMicrogalsMul = UnitMicrogalsMul;
pub type Nanogals<T> = Quantity<T, UnitNanogals>;
#[allow(non_upper_case_globals)]
pub static Nanogals: UnitNanogalsMul = UnitNanogalsMul;
pub type Picogals<T> = Quantity<T, UnitPicogals>;
#[allow(non_upper_case_globals)]
pub static Picogals: UnitPicogalsMul = UnitPicogalsMul;
pub type Femtogals<T> = Quantity<T, UnitFemtogals>;
#[allow(non_upper_case_globals)]
pub static Femtogals: UnitFemtogalsMul = UnitFemtogalsMul;
pub type Attogals<T> = Quantity<T, UnitAttogals>;
#[allow(non_upper_case_globals)]
pub static Attogals: UnitAttogalsMul = UnitAttogalsMul;
pub type Zeptogals<T> = Quantity<T, UnitZeptogals>;
#[allow(non_upper_case_globals)]
pub static Zeptogals: UnitZeptogalsMul = UnitZeptogalsMul;
pub type Yoctogals<T> = Quantity<T, UnitYoctogals>;
#[allow(non_upper_case_globals)]
pub static Yoctogals: UnitYoctogalsMul = UnitYoctogalsMul;
pub type Rontogals<T> = Quantity<T, UnitRontogals>;
#[allow(non_upper_case_globals)]
pub static Rontogals: UnitRontogalsMul = UnitRontogalsMul;
pub type Quectogals<T> = Quantity<T, UnitQuectogals>;
#[allow(non_upper_case_globals)]
pub static Quectogals: UnitQuectogalsMul = UnitQuectogalsMul;
pub struct UnitDynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDynes {
    #[inline]
    fn clone(&self) -> UnitDynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDynes {
    #[inline]
    fn eq(&self, other: &UnitDynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDynes {
    fn default() -> Self {
        UnitDynes
    }
}
impl Add<UnitDynes> for UnitDynes {
    type Output = UnitDynes;
    #[inline]
    fn add(self, _: UnitDynes) -> Self::Output {
        UnitDynes
    }
}
impl AddAssign<UnitDynes> for UnitDynes {
    #[inline]
    fn add_assign(&mut self, _: UnitDynes) {}
}
impl Sub<UnitDynes> for UnitDynes {
    type Output = UnitDynes;
    #[inline]
    fn sub(self, _: UnitDynes) -> Self::Output {
        UnitDynes
    }
}
impl SubAssign<UnitDynes> for UnitDynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDynes) {}
}
pub struct UnitDynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDynesMul {
    #[inline]
    fn clone(&self) -> UnitDynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDynesMul {
    #[inline]
    fn eq(&self, other: &UnitDynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDynesMul> for i8 {
    type Output = Quantity<i8, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for i16 {
    type Output = Quantity<i16, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for i32 {
    type Output = Quantity<i32, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for i64 {
    type Output = Quantity<i64, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for i128 {
    type Output = Quantity<i128, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for isize {
    type Output = Quantity<isize, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for u8 {
    type Output = Quantity<u8, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for u16 {
    type Output = Quantity<u16, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for u32 {
    type Output = Quantity<u32, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for u64 {
    type Output = Quantity<u64, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for u128 {
    type Output = Quantity<u128, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for usize {
    type Output = Quantity<usize, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for f32 {
    type Output = Quantity<f32, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
impl Mul<UnitDynesMul> for f64 {
    type Output = Quantity<f64, UnitDynes>;
    fn mul(self, _: UnitDynesMul) -> Self::Output {
        Quantity::new(self, UnitDynes)
    }
}
pub struct UnitQuettadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettadynes {
    #[inline]
    fn clone(&self) -> UnitQuettadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettadynes {
    #[inline]
    fn eq(&self, other: &UnitQuettadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettadynes {
    fn default() -> Self {
        UnitQuettadynes
    }
}
impl Add<UnitQuettadynes> for UnitQuettadynes {
    type Output = UnitQuettadynes;
    #[inline]
    fn add(self, _: UnitQuettadynes) -> Self::Output {
        UnitQuettadynes
    }
}
impl AddAssign<UnitQuettadynes> for UnitQuettadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettadynes) {}
}
impl Sub<UnitQuettadynes> for UnitQuettadynes {
    type Output = UnitQuettadynes;
    #[inline]
    fn sub(self, _: UnitQuettadynes) -> Self::Output {
        UnitQuettadynes
    }
}
impl SubAssign<UnitQuettadynes> for UnitQuettadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettadynes) {}
}
pub struct UnitQuettadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettadynesMul {
    #[inline]
    fn clone(&self) -> UnitQuettadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettadynesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettadynesMul> for i8 {
    type Output = Quantity<i8, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for i16 {
    type Output = Quantity<i16, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for i32 {
    type Output = Quantity<i32, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for i64 {
    type Output = Quantity<i64, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for i128 {
    type Output = Quantity<i128, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for isize {
    type Output = Quantity<isize, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for u8 {
    type Output = Quantity<u8, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for u16 {
    type Output = Quantity<u16, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for u32 {
    type Output = Quantity<u32, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for u64 {
    type Output = Quantity<u64, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for u128 {
    type Output = Quantity<u128, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for usize {
    type Output = Quantity<usize, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for f32 {
    type Output = Quantity<f32, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
impl Mul<UnitQuettadynesMul> for f64 {
    type Output = Quantity<f64, UnitQuettadynes>;
    fn mul(self, _: UnitQuettadynesMul) -> Self::Output {
        Quantity::new(self, UnitQuettadynes)
    }
}
pub struct UnitRonnadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnadynes {
    #[inline]
    fn clone(&self) -> UnitRonnadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnadynes {
    #[inline]
    fn eq(&self, other: &UnitRonnadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnadynes {
    fn default() -> Self {
        UnitRonnadynes
    }
}
impl Add<UnitRonnadynes> for UnitRonnadynes {
    type Output = UnitRonnadynes;
    #[inline]
    fn add(self, _: UnitRonnadynes) -> Self::Output {
        UnitRonnadynes
    }
}
impl AddAssign<UnitRonnadynes> for UnitRonnadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnadynes) {}
}
impl Sub<UnitRonnadynes> for UnitRonnadynes {
    type Output = UnitRonnadynes;
    #[inline]
    fn sub(self, _: UnitRonnadynes) -> Self::Output {
        UnitRonnadynes
    }
}
impl SubAssign<UnitRonnadynes> for UnitRonnadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnadynes) {}
}
pub struct UnitRonnadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnadynesMul {
    #[inline]
    fn clone(&self) -> UnitRonnadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnadynesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnadynesMul> for i8 {
    type Output = Quantity<i8, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for i16 {
    type Output = Quantity<i16, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for i32 {
    type Output = Quantity<i32, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for i64 {
    type Output = Quantity<i64, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for i128 {
    type Output = Quantity<i128, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for isize {
    type Output = Quantity<isize, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for u8 {
    type Output = Quantity<u8, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for u16 {
    type Output = Quantity<u16, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for u32 {
    type Output = Quantity<u32, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for u64 {
    type Output = Quantity<u64, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for u128 {
    type Output = Quantity<u128, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for usize {
    type Output = Quantity<usize, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for f32 {
    type Output = Quantity<f32, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
impl Mul<UnitRonnadynesMul> for f64 {
    type Output = Quantity<f64, UnitRonnadynes>;
    fn mul(self, _: UnitRonnadynesMul) -> Self::Output {
        Quantity::new(self, UnitRonnadynes)
    }
}
pub struct UnitYottadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottadynes {
    #[inline]
    fn clone(&self) -> UnitYottadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottadynes {
    #[inline]
    fn eq(&self, other: &UnitYottadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottadynes {
    fn default() -> Self {
        UnitYottadynes
    }
}
impl Add<UnitYottadynes> for UnitYottadynes {
    type Output = UnitYottadynes;
    #[inline]
    fn add(self, _: UnitYottadynes) -> Self::Output {
        UnitYottadynes
    }
}
impl AddAssign<UnitYottadynes> for UnitYottadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitYottadynes) {}
}
impl Sub<UnitYottadynes> for UnitYottadynes {
    type Output = UnitYottadynes;
    #[inline]
    fn sub(self, _: UnitYottadynes) -> Self::Output {
        UnitYottadynes
    }
}
impl SubAssign<UnitYottadynes> for UnitYottadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottadynes) {}
}
pub struct UnitYottadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottadynesMul {
    #[inline]
    fn clone(&self) -> UnitYottadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottadynesMul {
    #[inline]
    fn eq(&self, other: &UnitYottadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottadynesMul> for i8 {
    type Output = Quantity<i8, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for i16 {
    type Output = Quantity<i16, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for i32 {
    type Output = Quantity<i32, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for i64 {
    type Output = Quantity<i64, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for i128 {
    type Output = Quantity<i128, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for isize {
    type Output = Quantity<isize, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for u8 {
    type Output = Quantity<u8, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for u16 {
    type Output = Quantity<u16, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for u32 {
    type Output = Quantity<u32, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for u64 {
    type Output = Quantity<u64, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for u128 {
    type Output = Quantity<u128, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for usize {
    type Output = Quantity<usize, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for f32 {
    type Output = Quantity<f32, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
impl Mul<UnitYottadynesMul> for f64 {
    type Output = Quantity<f64, UnitYottadynes>;
    fn mul(self, _: UnitYottadynesMul) -> Self::Output {
        Quantity::new(self, UnitYottadynes)
    }
}
pub struct UnitZettadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettadynes {
    #[inline]
    fn clone(&self) -> UnitZettadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettadynes {
    #[inline]
    fn eq(&self, other: &UnitZettadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettadynes {
    fn default() -> Self {
        UnitZettadynes
    }
}
impl Add<UnitZettadynes> for UnitZettadynes {
    type Output = UnitZettadynes;
    #[inline]
    fn add(self, _: UnitZettadynes) -> Self::Output {
        UnitZettadynes
    }
}
impl AddAssign<UnitZettadynes> for UnitZettadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitZettadynes) {}
}
impl Sub<UnitZettadynes> for UnitZettadynes {
    type Output = UnitZettadynes;
    #[inline]
    fn sub(self, _: UnitZettadynes) -> Self::Output {
        UnitZettadynes
    }
}
impl SubAssign<UnitZettadynes> for UnitZettadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettadynes) {}
}
pub struct UnitZettadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettadynesMul {
    #[inline]
    fn clone(&self) -> UnitZettadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettadynesMul {
    #[inline]
    fn eq(&self, other: &UnitZettadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettadynesMul> for i8 {
    type Output = Quantity<i8, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for i16 {
    type Output = Quantity<i16, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for i32 {
    type Output = Quantity<i32, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for i64 {
    type Output = Quantity<i64, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for i128 {
    type Output = Quantity<i128, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for isize {
    type Output = Quantity<isize, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for u8 {
    type Output = Quantity<u8, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for u16 {
    type Output = Quantity<u16, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for u32 {
    type Output = Quantity<u32, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for u64 {
    type Output = Quantity<u64, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for u128 {
    type Output = Quantity<u128, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for usize {
    type Output = Quantity<usize, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for f32 {
    type Output = Quantity<f32, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
impl Mul<UnitZettadynesMul> for f64 {
    type Output = Quantity<f64, UnitZettadynes>;
    fn mul(self, _: UnitZettadynesMul) -> Self::Output {
        Quantity::new(self, UnitZettadynes)
    }
}
pub struct UnitExadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExadynes {
    #[inline]
    fn clone(&self) -> UnitExadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExadynes {
    #[inline]
    fn eq(&self, other: &UnitExadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExadynes {
    fn default() -> Self {
        UnitExadynes
    }
}
impl Add<UnitExadynes> for UnitExadynes {
    type Output = UnitExadynes;
    #[inline]
    fn add(self, _: UnitExadynes) -> Self::Output {
        UnitExadynes
    }
}
impl AddAssign<UnitExadynes> for UnitExadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitExadynes) {}
}
impl Sub<UnitExadynes> for UnitExadynes {
    type Output = UnitExadynes;
    #[inline]
    fn sub(self, _: UnitExadynes) -> Self::Output {
        UnitExadynes
    }
}
impl SubAssign<UnitExadynes> for UnitExadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitExadynes) {}
}
pub struct UnitExadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExadynesMul {
    #[inline]
    fn clone(&self) -> UnitExadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExadynesMul {
    #[inline]
    fn eq(&self, other: &UnitExadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExadynesMul> for i8 {
    type Output = Quantity<i8, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for i16 {
    type Output = Quantity<i16, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for i32 {
    type Output = Quantity<i32, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for i64 {
    type Output = Quantity<i64, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for i128 {
    type Output = Quantity<i128, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for isize {
    type Output = Quantity<isize, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for u8 {
    type Output = Quantity<u8, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for u16 {
    type Output = Quantity<u16, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for u32 {
    type Output = Quantity<u32, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for u64 {
    type Output = Quantity<u64, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for u128 {
    type Output = Quantity<u128, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for usize {
    type Output = Quantity<usize, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for f32 {
    type Output = Quantity<f32, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
impl Mul<UnitExadynesMul> for f64 {
    type Output = Quantity<f64, UnitExadynes>;
    fn mul(self, _: UnitExadynesMul) -> Self::Output {
        Quantity::new(self, UnitExadynes)
    }
}
pub struct UnitPetadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetadynes {
    #[inline]
    fn clone(&self) -> UnitPetadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetadynes {
    #[inline]
    fn eq(&self, other: &UnitPetadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetadynes {
    fn default() -> Self {
        UnitPetadynes
    }
}
impl Add<UnitPetadynes> for UnitPetadynes {
    type Output = UnitPetadynes;
    #[inline]
    fn add(self, _: UnitPetadynes) -> Self::Output {
        UnitPetadynes
    }
}
impl AddAssign<UnitPetadynes> for UnitPetadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitPetadynes) {}
}
impl Sub<UnitPetadynes> for UnitPetadynes {
    type Output = UnitPetadynes;
    #[inline]
    fn sub(self, _: UnitPetadynes) -> Self::Output {
        UnitPetadynes
    }
}
impl SubAssign<UnitPetadynes> for UnitPetadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetadynes) {}
}
pub struct UnitPetadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetadynesMul {
    #[inline]
    fn clone(&self) -> UnitPetadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetadynesMul {
    #[inline]
    fn eq(&self, other: &UnitPetadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetadynesMul> for i8 {
    type Output = Quantity<i8, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for i16 {
    type Output = Quantity<i16, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for i32 {
    type Output = Quantity<i32, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for i64 {
    type Output = Quantity<i64, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for i128 {
    type Output = Quantity<i128, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for isize {
    type Output = Quantity<isize, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for u8 {
    type Output = Quantity<u8, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for u16 {
    type Output = Quantity<u16, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for u32 {
    type Output = Quantity<u32, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for u64 {
    type Output = Quantity<u64, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for u128 {
    type Output = Quantity<u128, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for usize {
    type Output = Quantity<usize, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for f32 {
    type Output = Quantity<f32, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
impl Mul<UnitPetadynesMul> for f64 {
    type Output = Quantity<f64, UnitPetadynes>;
    fn mul(self, _: UnitPetadynesMul) -> Self::Output {
        Quantity::new(self, UnitPetadynes)
    }
}
pub struct UnitTeradynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeradynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeradynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeradynes {
    #[inline]
    fn clone(&self) -> UnitTeradynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeradynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeradynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeradynes {
    #[inline]
    fn eq(&self, other: &UnitTeradynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeradynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeradynes {
    fn default() -> Self {
        UnitTeradynes
    }
}
impl Add<UnitTeradynes> for UnitTeradynes {
    type Output = UnitTeradynes;
    #[inline]
    fn add(self, _: UnitTeradynes) -> Self::Output {
        UnitTeradynes
    }
}
impl AddAssign<UnitTeradynes> for UnitTeradynes {
    #[inline]
    fn add_assign(&mut self, _: UnitTeradynes) {}
}
impl Sub<UnitTeradynes> for UnitTeradynes {
    type Output = UnitTeradynes;
    #[inline]
    fn sub(self, _: UnitTeradynes) -> Self::Output {
        UnitTeradynes
    }
}
impl SubAssign<UnitTeradynes> for UnitTeradynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeradynes) {}
}
pub struct UnitTeradynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeradynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeradynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeradynesMul {
    #[inline]
    fn clone(&self) -> UnitTeradynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeradynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeradynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeradynesMul {
    #[inline]
    fn eq(&self, other: &UnitTeradynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeradynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeradynesMul> for i8 {
    type Output = Quantity<i8, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for i16 {
    type Output = Quantity<i16, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for i32 {
    type Output = Quantity<i32, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for i64 {
    type Output = Quantity<i64, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for i128 {
    type Output = Quantity<i128, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for isize {
    type Output = Quantity<isize, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for u8 {
    type Output = Quantity<u8, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for u16 {
    type Output = Quantity<u16, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for u32 {
    type Output = Quantity<u32, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for u64 {
    type Output = Quantity<u64, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for u128 {
    type Output = Quantity<u128, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for usize {
    type Output = Quantity<usize, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for f32 {
    type Output = Quantity<f32, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
impl Mul<UnitTeradynesMul> for f64 {
    type Output = Quantity<f64, UnitTeradynes>;
    fn mul(self, _: UnitTeradynesMul) -> Self::Output {
        Quantity::new(self, UnitTeradynes)
    }
}
pub struct UnitGigadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigadynes {
    #[inline]
    fn clone(&self) -> UnitGigadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigadynes {
    #[inline]
    fn eq(&self, other: &UnitGigadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigadynes {
    fn default() -> Self {
        UnitGigadynes
    }
}
impl Add<UnitGigadynes> for UnitGigadynes {
    type Output = UnitGigadynes;
    #[inline]
    fn add(self, _: UnitGigadynes) -> Self::Output {
        UnitGigadynes
    }
}
impl AddAssign<UnitGigadynes> for UnitGigadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitGigadynes) {}
}
impl Sub<UnitGigadynes> for UnitGigadynes {
    type Output = UnitGigadynes;
    #[inline]
    fn sub(self, _: UnitGigadynes) -> Self::Output {
        UnitGigadynes
    }
}
impl SubAssign<UnitGigadynes> for UnitGigadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigadynes) {}
}
pub struct UnitGigadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigadynesMul {
    #[inline]
    fn clone(&self) -> UnitGigadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigadynesMul {
    #[inline]
    fn eq(&self, other: &UnitGigadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigadynesMul> for i8 {
    type Output = Quantity<i8, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for i16 {
    type Output = Quantity<i16, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for i32 {
    type Output = Quantity<i32, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for i64 {
    type Output = Quantity<i64, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for i128 {
    type Output = Quantity<i128, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for isize {
    type Output = Quantity<isize, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for u8 {
    type Output = Quantity<u8, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for u16 {
    type Output = Quantity<u16, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for u32 {
    type Output = Quantity<u32, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for u64 {
    type Output = Quantity<u64, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for u128 {
    type Output = Quantity<u128, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for usize {
    type Output = Quantity<usize, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for f32 {
    type Output = Quantity<f32, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
impl Mul<UnitGigadynesMul> for f64 {
    type Output = Quantity<f64, UnitGigadynes>;
    fn mul(self, _: UnitGigadynesMul) -> Self::Output {
        Quantity::new(self, UnitGigadynes)
    }
}
pub struct UnitMegadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegadynes {
    #[inline]
    fn clone(&self) -> UnitMegadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegadynes {
    #[inline]
    fn eq(&self, other: &UnitMegadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegadynes {
    fn default() -> Self {
        UnitMegadynes
    }
}
impl Add<UnitMegadynes> for UnitMegadynes {
    type Output = UnitMegadynes;
    #[inline]
    fn add(self, _: UnitMegadynes) -> Self::Output {
        UnitMegadynes
    }
}
impl AddAssign<UnitMegadynes> for UnitMegadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitMegadynes) {}
}
impl Sub<UnitMegadynes> for UnitMegadynes {
    type Output = UnitMegadynes;
    #[inline]
    fn sub(self, _: UnitMegadynes) -> Self::Output {
        UnitMegadynes
    }
}
impl SubAssign<UnitMegadynes> for UnitMegadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegadynes) {}
}
pub struct UnitMegadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegadynesMul {
    #[inline]
    fn clone(&self) -> UnitMegadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegadynesMul {
    #[inline]
    fn eq(&self, other: &UnitMegadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegadynesMul> for i8 {
    type Output = Quantity<i8, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for i16 {
    type Output = Quantity<i16, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for i32 {
    type Output = Quantity<i32, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for i64 {
    type Output = Quantity<i64, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for i128 {
    type Output = Quantity<i128, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for isize {
    type Output = Quantity<isize, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for u8 {
    type Output = Quantity<u8, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for u16 {
    type Output = Quantity<u16, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for u32 {
    type Output = Quantity<u32, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for u64 {
    type Output = Quantity<u64, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for u128 {
    type Output = Quantity<u128, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for usize {
    type Output = Quantity<usize, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for f32 {
    type Output = Quantity<f32, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
impl Mul<UnitMegadynesMul> for f64 {
    type Output = Quantity<f64, UnitMegadynes>;
    fn mul(self, _: UnitMegadynesMul) -> Self::Output {
        Quantity::new(self, UnitMegadynes)
    }
}
pub struct UnitKilodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilodynes {
    #[inline]
    fn clone(&self) -> UnitKilodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilodynes {
    #[inline]
    fn eq(&self, other: &UnitKilodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilodynes {
    fn default() -> Self {
        UnitKilodynes
    }
}
impl Add<UnitKilodynes> for UnitKilodynes {
    type Output = UnitKilodynes;
    #[inline]
    fn add(self, _: UnitKilodynes) -> Self::Output {
        UnitKilodynes
    }
}
impl AddAssign<UnitKilodynes> for UnitKilodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitKilodynes) {}
}
impl Sub<UnitKilodynes> for UnitKilodynes {
    type Output = UnitKilodynes;
    #[inline]
    fn sub(self, _: UnitKilodynes) -> Self::Output {
        UnitKilodynes
    }
}
impl SubAssign<UnitKilodynes> for UnitKilodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilodynes) {}
}
pub struct UnitKilodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilodynesMul {
    #[inline]
    fn clone(&self) -> UnitKilodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilodynesMul {
    #[inline]
    fn eq(&self, other: &UnitKilodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilodynesMul> for i8 {
    type Output = Quantity<i8, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for i16 {
    type Output = Quantity<i16, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for i32 {
    type Output = Quantity<i32, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for i64 {
    type Output = Quantity<i64, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for i128 {
    type Output = Quantity<i128, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for isize {
    type Output = Quantity<isize, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for u8 {
    type Output = Quantity<u8, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for u16 {
    type Output = Quantity<u16, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for u32 {
    type Output = Quantity<u32, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for u64 {
    type Output = Quantity<u64, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for u128 {
    type Output = Quantity<u128, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for usize {
    type Output = Quantity<usize, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for f32 {
    type Output = Quantity<f32, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
impl Mul<UnitKilodynesMul> for f64 {
    type Output = Quantity<f64, UnitKilodynes>;
    fn mul(self, _: UnitKilodynesMul) -> Self::Output {
        Quantity::new(self, UnitKilodynes)
    }
}
pub struct UnitHectodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectodynes {
    #[inline]
    fn clone(&self) -> UnitHectodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectodynes {
    #[inline]
    fn eq(&self, other: &UnitHectodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectodynes {
    fn default() -> Self {
        UnitHectodynes
    }
}
impl Add<UnitHectodynes> for UnitHectodynes {
    type Output = UnitHectodynes;
    #[inline]
    fn add(self, _: UnitHectodynes) -> Self::Output {
        UnitHectodynes
    }
}
impl AddAssign<UnitHectodynes> for UnitHectodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitHectodynes) {}
}
impl Sub<UnitHectodynes> for UnitHectodynes {
    type Output = UnitHectodynes;
    #[inline]
    fn sub(self, _: UnitHectodynes) -> Self::Output {
        UnitHectodynes
    }
}
impl SubAssign<UnitHectodynes> for UnitHectodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectodynes) {}
}
pub struct UnitHectodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectodynesMul {
    #[inline]
    fn clone(&self) -> UnitHectodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectodynesMul {
    #[inline]
    fn eq(&self, other: &UnitHectodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectodynesMul> for i8 {
    type Output = Quantity<i8, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for i16 {
    type Output = Quantity<i16, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for i32 {
    type Output = Quantity<i32, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for i64 {
    type Output = Quantity<i64, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for i128 {
    type Output = Quantity<i128, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for isize {
    type Output = Quantity<isize, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for u8 {
    type Output = Quantity<u8, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for u16 {
    type Output = Quantity<u16, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for u32 {
    type Output = Quantity<u32, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for u64 {
    type Output = Quantity<u64, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for u128 {
    type Output = Quantity<u128, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for usize {
    type Output = Quantity<usize, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for f32 {
    type Output = Quantity<f32, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
impl Mul<UnitHectodynesMul> for f64 {
    type Output = Quantity<f64, UnitHectodynes>;
    fn mul(self, _: UnitHectodynesMul) -> Self::Output {
        Quantity::new(self, UnitHectodynes)
    }
}
pub struct UnitDecadynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecadynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecadynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecadynes {
    #[inline]
    fn clone(&self) -> UnitDecadynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecadynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecadynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecadynes {
    #[inline]
    fn eq(&self, other: &UnitDecadynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecadynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecadynes {
    fn default() -> Self {
        UnitDecadynes
    }
}
impl Add<UnitDecadynes> for UnitDecadynes {
    type Output = UnitDecadynes;
    #[inline]
    fn add(self, _: UnitDecadynes) -> Self::Output {
        UnitDecadynes
    }
}
impl AddAssign<UnitDecadynes> for UnitDecadynes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecadynes) {}
}
impl Sub<UnitDecadynes> for UnitDecadynes {
    type Output = UnitDecadynes;
    #[inline]
    fn sub(self, _: UnitDecadynes) -> Self::Output {
        UnitDecadynes
    }
}
impl SubAssign<UnitDecadynes> for UnitDecadynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecadynes) {}
}
pub struct UnitDecadynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecadynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecadynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecadynesMul {
    #[inline]
    fn clone(&self) -> UnitDecadynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecadynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecadynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecadynesMul {
    #[inline]
    fn eq(&self, other: &UnitDecadynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecadynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecadynesMul> for i8 {
    type Output = Quantity<i8, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for i16 {
    type Output = Quantity<i16, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for i32 {
    type Output = Quantity<i32, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for i64 {
    type Output = Quantity<i64, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for i128 {
    type Output = Quantity<i128, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for isize {
    type Output = Quantity<isize, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for u8 {
    type Output = Quantity<u8, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for u16 {
    type Output = Quantity<u16, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for u32 {
    type Output = Quantity<u32, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for u64 {
    type Output = Quantity<u64, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for u128 {
    type Output = Quantity<u128, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for usize {
    type Output = Quantity<usize, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for f32 {
    type Output = Quantity<f32, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
impl Mul<UnitDecadynesMul> for f64 {
    type Output = Quantity<f64, UnitDecadynes>;
    fn mul(self, _: UnitDecadynesMul) -> Self::Output {
        Quantity::new(self, UnitDecadynes)
    }
}
pub struct UnitDecidynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecidynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecidynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecidynes {
    #[inline]
    fn clone(&self) -> UnitDecidynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecidynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecidynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecidynes {
    #[inline]
    fn eq(&self, other: &UnitDecidynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecidynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecidynes {
    fn default() -> Self {
        UnitDecidynes
    }
}
impl Add<UnitDecidynes> for UnitDecidynes {
    type Output = UnitDecidynes;
    #[inline]
    fn add(self, _: UnitDecidynes) -> Self::Output {
        UnitDecidynes
    }
}
impl AddAssign<UnitDecidynes> for UnitDecidynes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecidynes) {}
}
impl Sub<UnitDecidynes> for UnitDecidynes {
    type Output = UnitDecidynes;
    #[inline]
    fn sub(self, _: UnitDecidynes) -> Self::Output {
        UnitDecidynes
    }
}
impl SubAssign<UnitDecidynes> for UnitDecidynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecidynes) {}
}
pub struct UnitDecidynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecidynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecidynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecidynesMul {
    #[inline]
    fn clone(&self) -> UnitDecidynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecidynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecidynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecidynesMul {
    #[inline]
    fn eq(&self, other: &UnitDecidynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecidynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecidynesMul> for i8 {
    type Output = Quantity<i8, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for i16 {
    type Output = Quantity<i16, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for i32 {
    type Output = Quantity<i32, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for i64 {
    type Output = Quantity<i64, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for i128 {
    type Output = Quantity<i128, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for isize {
    type Output = Quantity<isize, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for u8 {
    type Output = Quantity<u8, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for u16 {
    type Output = Quantity<u16, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for u32 {
    type Output = Quantity<u32, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for u64 {
    type Output = Quantity<u64, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for u128 {
    type Output = Quantity<u128, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for usize {
    type Output = Quantity<usize, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for f32 {
    type Output = Quantity<f32, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
impl Mul<UnitDecidynesMul> for f64 {
    type Output = Quantity<f64, UnitDecidynes>;
    fn mul(self, _: UnitDecidynesMul) -> Self::Output {
        Quantity::new(self, UnitDecidynes)
    }
}
pub struct UnitCentidynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentidynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentidynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentidynes {
    #[inline]
    fn clone(&self) -> UnitCentidynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentidynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentidynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentidynes {
    #[inline]
    fn eq(&self, other: &UnitCentidynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentidynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentidynes {
    fn default() -> Self {
        UnitCentidynes
    }
}
impl Add<UnitCentidynes> for UnitCentidynes {
    type Output = UnitCentidynes;
    #[inline]
    fn add(self, _: UnitCentidynes) -> Self::Output {
        UnitCentidynes
    }
}
impl AddAssign<UnitCentidynes> for UnitCentidynes {
    #[inline]
    fn add_assign(&mut self, _: UnitCentidynes) {}
}
impl Sub<UnitCentidynes> for UnitCentidynes {
    type Output = UnitCentidynes;
    #[inline]
    fn sub(self, _: UnitCentidynes) -> Self::Output {
        UnitCentidynes
    }
}
impl SubAssign<UnitCentidynes> for UnitCentidynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentidynes) {}
}
pub struct UnitCentidynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentidynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentidynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentidynesMul {
    #[inline]
    fn clone(&self) -> UnitCentidynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentidynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentidynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentidynesMul {
    #[inline]
    fn eq(&self, other: &UnitCentidynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentidynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentidynesMul> for i8 {
    type Output = Quantity<i8, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for i16 {
    type Output = Quantity<i16, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for i32 {
    type Output = Quantity<i32, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for i64 {
    type Output = Quantity<i64, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for i128 {
    type Output = Quantity<i128, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for isize {
    type Output = Quantity<isize, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for u8 {
    type Output = Quantity<u8, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for u16 {
    type Output = Quantity<u16, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for u32 {
    type Output = Quantity<u32, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for u64 {
    type Output = Quantity<u64, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for u128 {
    type Output = Quantity<u128, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for usize {
    type Output = Quantity<usize, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for f32 {
    type Output = Quantity<f32, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
impl Mul<UnitCentidynesMul> for f64 {
    type Output = Quantity<f64, UnitCentidynes>;
    fn mul(self, _: UnitCentidynesMul) -> Self::Output {
        Quantity::new(self, UnitCentidynes)
    }
}
pub struct UnitMillidynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillidynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillidynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillidynes {
    #[inline]
    fn clone(&self) -> UnitMillidynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillidynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillidynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillidynes {
    #[inline]
    fn eq(&self, other: &UnitMillidynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillidynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillidynes {
    fn default() -> Self {
        UnitMillidynes
    }
}
impl Add<UnitMillidynes> for UnitMillidynes {
    type Output = UnitMillidynes;
    #[inline]
    fn add(self, _: UnitMillidynes) -> Self::Output {
        UnitMillidynes
    }
}
impl AddAssign<UnitMillidynes> for UnitMillidynes {
    #[inline]
    fn add_assign(&mut self, _: UnitMillidynes) {}
}
impl Sub<UnitMillidynes> for UnitMillidynes {
    type Output = UnitMillidynes;
    #[inline]
    fn sub(self, _: UnitMillidynes) -> Self::Output {
        UnitMillidynes
    }
}
impl SubAssign<UnitMillidynes> for UnitMillidynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillidynes) {}
}
pub struct UnitMillidynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillidynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillidynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillidynesMul {
    #[inline]
    fn clone(&self) -> UnitMillidynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillidynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillidynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillidynesMul {
    #[inline]
    fn eq(&self, other: &UnitMillidynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillidynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillidynesMul> for i8 {
    type Output = Quantity<i8, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for i16 {
    type Output = Quantity<i16, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for i32 {
    type Output = Quantity<i32, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for i64 {
    type Output = Quantity<i64, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for i128 {
    type Output = Quantity<i128, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for isize {
    type Output = Quantity<isize, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for u8 {
    type Output = Quantity<u8, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for u16 {
    type Output = Quantity<u16, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for u32 {
    type Output = Quantity<u32, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for u64 {
    type Output = Quantity<u64, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for u128 {
    type Output = Quantity<u128, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for usize {
    type Output = Quantity<usize, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for f32 {
    type Output = Quantity<f32, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
impl Mul<UnitMillidynesMul> for f64 {
    type Output = Quantity<f64, UnitMillidynes>;
    fn mul(self, _: UnitMillidynesMul) -> Self::Output {
        Quantity::new(self, UnitMillidynes)
    }
}
pub struct UnitMicrodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrodynes {
    #[inline]
    fn clone(&self) -> UnitMicrodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrodynes {
    #[inline]
    fn eq(&self, other: &UnitMicrodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrodynes {
    fn default() -> Self {
        UnitMicrodynes
    }
}
impl Add<UnitMicrodynes> for UnitMicrodynes {
    type Output = UnitMicrodynes;
    #[inline]
    fn add(self, _: UnitMicrodynes) -> Self::Output {
        UnitMicrodynes
    }
}
impl AddAssign<UnitMicrodynes> for UnitMicrodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrodynes) {}
}
impl Sub<UnitMicrodynes> for UnitMicrodynes {
    type Output = UnitMicrodynes;
    #[inline]
    fn sub(self, _: UnitMicrodynes) -> Self::Output {
        UnitMicrodynes
    }
}
impl SubAssign<UnitMicrodynes> for UnitMicrodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrodynes) {}
}
pub struct UnitMicrodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrodynesMul {
    #[inline]
    fn clone(&self) -> UnitMicrodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrodynesMul {
    #[inline]
    fn eq(&self, other: &UnitMicrodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrodynesMul> for i8 {
    type Output = Quantity<i8, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for i16 {
    type Output = Quantity<i16, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for i32 {
    type Output = Quantity<i32, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for i64 {
    type Output = Quantity<i64, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for i128 {
    type Output = Quantity<i128, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for isize {
    type Output = Quantity<isize, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for u8 {
    type Output = Quantity<u8, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for u16 {
    type Output = Quantity<u16, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for u32 {
    type Output = Quantity<u32, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for u64 {
    type Output = Quantity<u64, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for u128 {
    type Output = Quantity<u128, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for usize {
    type Output = Quantity<usize, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for f32 {
    type Output = Quantity<f32, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
impl Mul<UnitMicrodynesMul> for f64 {
    type Output = Quantity<f64, UnitMicrodynes>;
    fn mul(self, _: UnitMicrodynesMul) -> Self::Output {
        Quantity::new(self, UnitMicrodynes)
    }
}
pub struct UnitNanodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanodynes {
    #[inline]
    fn clone(&self) -> UnitNanodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanodynes {
    #[inline]
    fn eq(&self, other: &UnitNanodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanodynes {
    fn default() -> Self {
        UnitNanodynes
    }
}
impl Add<UnitNanodynes> for UnitNanodynes {
    type Output = UnitNanodynes;
    #[inline]
    fn add(self, _: UnitNanodynes) -> Self::Output {
        UnitNanodynes
    }
}
impl AddAssign<UnitNanodynes> for UnitNanodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitNanodynes) {}
}
impl Sub<UnitNanodynes> for UnitNanodynes {
    type Output = UnitNanodynes;
    #[inline]
    fn sub(self, _: UnitNanodynes) -> Self::Output {
        UnitNanodynes
    }
}
impl SubAssign<UnitNanodynes> for UnitNanodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanodynes) {}
}
pub struct UnitNanodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanodynesMul {
    #[inline]
    fn clone(&self) -> UnitNanodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanodynesMul {
    #[inline]
    fn eq(&self, other: &UnitNanodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanodynesMul> for i8 {
    type Output = Quantity<i8, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for i16 {
    type Output = Quantity<i16, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for i32 {
    type Output = Quantity<i32, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for i64 {
    type Output = Quantity<i64, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for i128 {
    type Output = Quantity<i128, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for isize {
    type Output = Quantity<isize, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for u8 {
    type Output = Quantity<u8, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for u16 {
    type Output = Quantity<u16, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for u32 {
    type Output = Quantity<u32, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for u64 {
    type Output = Quantity<u64, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for u128 {
    type Output = Quantity<u128, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for usize {
    type Output = Quantity<usize, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for f32 {
    type Output = Quantity<f32, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
impl Mul<UnitNanodynesMul> for f64 {
    type Output = Quantity<f64, UnitNanodynes>;
    fn mul(self, _: UnitNanodynesMul) -> Self::Output {
        Quantity::new(self, UnitNanodynes)
    }
}
pub struct UnitPicodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicodynes {
    #[inline]
    fn clone(&self) -> UnitPicodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicodynes {
    #[inline]
    fn eq(&self, other: &UnitPicodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicodynes {
    fn default() -> Self {
        UnitPicodynes
    }
}
impl Add<UnitPicodynes> for UnitPicodynes {
    type Output = UnitPicodynes;
    #[inline]
    fn add(self, _: UnitPicodynes) -> Self::Output {
        UnitPicodynes
    }
}
impl AddAssign<UnitPicodynes> for UnitPicodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitPicodynes) {}
}
impl Sub<UnitPicodynes> for UnitPicodynes {
    type Output = UnitPicodynes;
    #[inline]
    fn sub(self, _: UnitPicodynes) -> Self::Output {
        UnitPicodynes
    }
}
impl SubAssign<UnitPicodynes> for UnitPicodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicodynes) {}
}
pub struct UnitPicodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicodynesMul {
    #[inline]
    fn clone(&self) -> UnitPicodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicodynesMul {
    #[inline]
    fn eq(&self, other: &UnitPicodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicodynesMul> for i8 {
    type Output = Quantity<i8, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for i16 {
    type Output = Quantity<i16, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for i32 {
    type Output = Quantity<i32, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for i64 {
    type Output = Quantity<i64, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for i128 {
    type Output = Quantity<i128, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for isize {
    type Output = Quantity<isize, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for u8 {
    type Output = Quantity<u8, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for u16 {
    type Output = Quantity<u16, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for u32 {
    type Output = Quantity<u32, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for u64 {
    type Output = Quantity<u64, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for u128 {
    type Output = Quantity<u128, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for usize {
    type Output = Quantity<usize, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for f32 {
    type Output = Quantity<f32, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
impl Mul<UnitPicodynesMul> for f64 {
    type Output = Quantity<f64, UnitPicodynes>;
    fn mul(self, _: UnitPicodynesMul) -> Self::Output {
        Quantity::new(self, UnitPicodynes)
    }
}
pub struct UnitFemtodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtodynes {
    #[inline]
    fn clone(&self) -> UnitFemtodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtodynes {
    #[inline]
    fn eq(&self, other: &UnitFemtodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtodynes {
    fn default() -> Self {
        UnitFemtodynes
    }
}
impl Add<UnitFemtodynes> for UnitFemtodynes {
    type Output = UnitFemtodynes;
    #[inline]
    fn add(self, _: UnitFemtodynes) -> Self::Output {
        UnitFemtodynes
    }
}
impl AddAssign<UnitFemtodynes> for UnitFemtodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtodynes) {}
}
impl Sub<UnitFemtodynes> for UnitFemtodynes {
    type Output = UnitFemtodynes;
    #[inline]
    fn sub(self, _: UnitFemtodynes) -> Self::Output {
        UnitFemtodynes
    }
}
impl SubAssign<UnitFemtodynes> for UnitFemtodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtodynes) {}
}
pub struct UnitFemtodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtodynesMul {
    #[inline]
    fn clone(&self) -> UnitFemtodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtodynesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtodynesMul> for i8 {
    type Output = Quantity<i8, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for i16 {
    type Output = Quantity<i16, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for i32 {
    type Output = Quantity<i32, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for i64 {
    type Output = Quantity<i64, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for i128 {
    type Output = Quantity<i128, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for isize {
    type Output = Quantity<isize, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for u8 {
    type Output = Quantity<u8, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for u16 {
    type Output = Quantity<u16, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for u32 {
    type Output = Quantity<u32, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for u64 {
    type Output = Quantity<u64, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for u128 {
    type Output = Quantity<u128, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for usize {
    type Output = Quantity<usize, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for f32 {
    type Output = Quantity<f32, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
impl Mul<UnitFemtodynesMul> for f64 {
    type Output = Quantity<f64, UnitFemtodynes>;
    fn mul(self, _: UnitFemtodynesMul) -> Self::Output {
        Quantity::new(self, UnitFemtodynes)
    }
}
pub struct UnitAttodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttodynes {
    #[inline]
    fn clone(&self) -> UnitAttodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttodynes {
    #[inline]
    fn eq(&self, other: &UnitAttodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttodynes {
    fn default() -> Self {
        UnitAttodynes
    }
}
impl Add<UnitAttodynes> for UnitAttodynes {
    type Output = UnitAttodynes;
    #[inline]
    fn add(self, _: UnitAttodynes) -> Self::Output {
        UnitAttodynes
    }
}
impl AddAssign<UnitAttodynes> for UnitAttodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitAttodynes) {}
}
impl Sub<UnitAttodynes> for UnitAttodynes {
    type Output = UnitAttodynes;
    #[inline]
    fn sub(self, _: UnitAttodynes) -> Self::Output {
        UnitAttodynes
    }
}
impl SubAssign<UnitAttodynes> for UnitAttodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttodynes) {}
}
pub struct UnitAttodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttodynesMul {
    #[inline]
    fn clone(&self) -> UnitAttodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttodynesMul {
    #[inline]
    fn eq(&self, other: &UnitAttodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttodynesMul> for i8 {
    type Output = Quantity<i8, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for i16 {
    type Output = Quantity<i16, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for i32 {
    type Output = Quantity<i32, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for i64 {
    type Output = Quantity<i64, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for i128 {
    type Output = Quantity<i128, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for isize {
    type Output = Quantity<isize, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for u8 {
    type Output = Quantity<u8, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for u16 {
    type Output = Quantity<u16, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for u32 {
    type Output = Quantity<u32, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for u64 {
    type Output = Quantity<u64, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for u128 {
    type Output = Quantity<u128, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for usize {
    type Output = Quantity<usize, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for f32 {
    type Output = Quantity<f32, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
impl Mul<UnitAttodynesMul> for f64 {
    type Output = Quantity<f64, UnitAttodynes>;
    fn mul(self, _: UnitAttodynesMul) -> Self::Output {
        Quantity::new(self, UnitAttodynes)
    }
}
pub struct UnitZeptodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptodynes {
    #[inline]
    fn clone(&self) -> UnitZeptodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptodynes {
    #[inline]
    fn eq(&self, other: &UnitZeptodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptodynes {
    fn default() -> Self {
        UnitZeptodynes
    }
}
impl Add<UnitZeptodynes> for UnitZeptodynes {
    type Output = UnitZeptodynes;
    #[inline]
    fn add(self, _: UnitZeptodynes) -> Self::Output {
        UnitZeptodynes
    }
}
impl AddAssign<UnitZeptodynes> for UnitZeptodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptodynes) {}
}
impl Sub<UnitZeptodynes> for UnitZeptodynes {
    type Output = UnitZeptodynes;
    #[inline]
    fn sub(self, _: UnitZeptodynes) -> Self::Output {
        UnitZeptodynes
    }
}
impl SubAssign<UnitZeptodynes> for UnitZeptodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptodynes) {}
}
pub struct UnitZeptodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptodynesMul {
    #[inline]
    fn clone(&self) -> UnitZeptodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptodynesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptodynesMul> for i8 {
    type Output = Quantity<i8, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for i16 {
    type Output = Quantity<i16, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for i32 {
    type Output = Quantity<i32, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for i64 {
    type Output = Quantity<i64, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for i128 {
    type Output = Quantity<i128, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for isize {
    type Output = Quantity<isize, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for u8 {
    type Output = Quantity<u8, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for u16 {
    type Output = Quantity<u16, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for u32 {
    type Output = Quantity<u32, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for u64 {
    type Output = Quantity<u64, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for u128 {
    type Output = Quantity<u128, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for usize {
    type Output = Quantity<usize, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for f32 {
    type Output = Quantity<f32, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
impl Mul<UnitZeptodynesMul> for f64 {
    type Output = Quantity<f64, UnitZeptodynes>;
    fn mul(self, _: UnitZeptodynesMul) -> Self::Output {
        Quantity::new(self, UnitZeptodynes)
    }
}
pub struct UnitYoctodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctodynes {
    #[inline]
    fn clone(&self) -> UnitYoctodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctodynes {
    #[inline]
    fn eq(&self, other: &UnitYoctodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctodynes {
    fn default() -> Self {
        UnitYoctodynes
    }
}
impl Add<UnitYoctodynes> for UnitYoctodynes {
    type Output = UnitYoctodynes;
    #[inline]
    fn add(self, _: UnitYoctodynes) -> Self::Output {
        UnitYoctodynes
    }
}
impl AddAssign<UnitYoctodynes> for UnitYoctodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctodynes) {}
}
impl Sub<UnitYoctodynes> for UnitYoctodynes {
    type Output = UnitYoctodynes;
    #[inline]
    fn sub(self, _: UnitYoctodynes) -> Self::Output {
        UnitYoctodynes
    }
}
impl SubAssign<UnitYoctodynes> for UnitYoctodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctodynes) {}
}
pub struct UnitYoctodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctodynesMul {
    #[inline]
    fn clone(&self) -> UnitYoctodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctodynesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctodynesMul> for i8 {
    type Output = Quantity<i8, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for i16 {
    type Output = Quantity<i16, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for i32 {
    type Output = Quantity<i32, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for i64 {
    type Output = Quantity<i64, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for i128 {
    type Output = Quantity<i128, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for isize {
    type Output = Quantity<isize, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for u8 {
    type Output = Quantity<u8, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for u16 {
    type Output = Quantity<u16, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for u32 {
    type Output = Quantity<u32, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for u64 {
    type Output = Quantity<u64, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for u128 {
    type Output = Quantity<u128, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for usize {
    type Output = Quantity<usize, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for f32 {
    type Output = Quantity<f32, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
impl Mul<UnitYoctodynesMul> for f64 {
    type Output = Quantity<f64, UnitYoctodynes>;
    fn mul(self, _: UnitYoctodynesMul) -> Self::Output {
        Quantity::new(self, UnitYoctodynes)
    }
}
pub struct UnitRontodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontodynes {
    #[inline]
    fn clone(&self) -> UnitRontodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontodynes {
    #[inline]
    fn eq(&self, other: &UnitRontodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontodynes {
    fn default() -> Self {
        UnitRontodynes
    }
}
impl Add<UnitRontodynes> for UnitRontodynes {
    type Output = UnitRontodynes;
    #[inline]
    fn add(self, _: UnitRontodynes) -> Self::Output {
        UnitRontodynes
    }
}
impl AddAssign<UnitRontodynes> for UnitRontodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitRontodynes) {}
}
impl Sub<UnitRontodynes> for UnitRontodynes {
    type Output = UnitRontodynes;
    #[inline]
    fn sub(self, _: UnitRontodynes) -> Self::Output {
        UnitRontodynes
    }
}
impl SubAssign<UnitRontodynes> for UnitRontodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontodynes) {}
}
pub struct UnitRontodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontodynesMul {
    #[inline]
    fn clone(&self) -> UnitRontodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontodynesMul {
    #[inline]
    fn eq(&self, other: &UnitRontodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontodynesMul> for i8 {
    type Output = Quantity<i8, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for i16 {
    type Output = Quantity<i16, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for i32 {
    type Output = Quantity<i32, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for i64 {
    type Output = Quantity<i64, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for i128 {
    type Output = Quantity<i128, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for isize {
    type Output = Quantity<isize, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for u8 {
    type Output = Quantity<u8, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for u16 {
    type Output = Quantity<u16, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for u32 {
    type Output = Quantity<u32, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for u64 {
    type Output = Quantity<u64, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for u128 {
    type Output = Quantity<u128, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for usize {
    type Output = Quantity<usize, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for f32 {
    type Output = Quantity<f32, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
impl Mul<UnitRontodynesMul> for f64 {
    type Output = Quantity<f64, UnitRontodynes>;
    fn mul(self, _: UnitRontodynesMul) -> Self::Output {
        Quantity::new(self, UnitRontodynes)
    }
}
pub struct UnitQuectodynes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectodynes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectodynes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectodynes {
    #[inline]
    fn clone(&self) -> UnitQuectodynes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectodynes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectodynes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectodynes {
    #[inline]
    fn eq(&self, other: &UnitQuectodynes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectodynes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectodynes {
    fn default() -> Self {
        UnitQuectodynes
    }
}
impl Add<UnitQuectodynes> for UnitQuectodynes {
    type Output = UnitQuectodynes;
    #[inline]
    fn add(self, _: UnitQuectodynes) -> Self::Output {
        UnitQuectodynes
    }
}
impl AddAssign<UnitQuectodynes> for UnitQuectodynes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectodynes) {}
}
impl Sub<UnitQuectodynes> for UnitQuectodynes {
    type Output = UnitQuectodynes;
    #[inline]
    fn sub(self, _: UnitQuectodynes) -> Self::Output {
        UnitQuectodynes
    }
}
impl SubAssign<UnitQuectodynes> for UnitQuectodynes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectodynes) {}
}
pub struct UnitQuectodynesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectodynesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectodynesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectodynesMul {
    #[inline]
    fn clone(&self) -> UnitQuectodynesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectodynesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectodynesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectodynesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectodynesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectodynesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectodynesMul> for i8 {
    type Output = Quantity<i8, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for i16 {
    type Output = Quantity<i16, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for i32 {
    type Output = Quantity<i32, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for i64 {
    type Output = Quantity<i64, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for i128 {
    type Output = Quantity<i128, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for isize {
    type Output = Quantity<isize, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for u8 {
    type Output = Quantity<u8, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for u16 {
    type Output = Quantity<u16, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for u32 {
    type Output = Quantity<u32, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for u64 {
    type Output = Quantity<u64, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for u128 {
    type Output = Quantity<u128, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for usize {
    type Output = Quantity<usize, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for f32 {
    type Output = Quantity<f32, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
impl Mul<UnitQuectodynesMul> for f64 {
    type Output = Quantity<f64, UnitQuectodynes>;
    fn mul(self, _: UnitQuectodynesMul) -> Self::Output {
        Quantity::new(self, UnitQuectodynes)
    }
}
pub type Dynes<T> = Quantity<T, UnitDynes>;
#[allow(non_upper_case_globals)]
pub static Dynes: UnitDynesMul = UnitDynesMul;
pub type Quettadynes<T> = Quantity<T, UnitQuettadynes>;
#[allow(non_upper_case_globals)]
pub static Quettadynes: UnitQuettadynesMul = UnitQuettadynesMul;
pub type Ronnadynes<T> = Quantity<T, UnitRonnadynes>;
#[allow(non_upper_case_globals)]
pub static Ronnadynes: UnitRonnadynesMul = UnitRonnadynesMul;
pub type Yottadynes<T> = Quantity<T, UnitYottadynes>;
#[allow(non_upper_case_globals)]
pub static Yottadynes: UnitYottadynesMul = UnitYottadynesMul;
pub type Zettadynes<T> = Quantity<T, UnitZettadynes>;
#[allow(non_upper_case_globals)]
pub static Zettadynes: UnitZettadynesMul = UnitZettadynesMul;
pub type Exadynes<T> = Quantity<T, UnitExadynes>;
#[allow(non_upper_case_globals)]
pub static Exadynes: UnitExadynesMul = UnitExadynesMul;
pub type Petadynes<T> = Quantity<T, UnitPetadynes>;
#[allow(non_upper_case_globals)]
pub static Petadynes: UnitPetadynesMul = UnitPetadynesMul;
pub type Teradynes<T> = Quantity<T, UnitTeradynes>;
#[allow(non_upper_case_globals)]
pub static Teradynes: UnitTeradynesMul = UnitTeradynesMul;
pub type Gigadynes<T> = Quantity<T, UnitGigadynes>;
#[allow(non_upper_case_globals)]
pub static Gigadynes: UnitGigadynesMul = UnitGigadynesMul;
pub type Megadynes<T> = Quantity<T, UnitMegadynes>;
#[allow(non_upper_case_globals)]
pub static Megadynes: UnitMegadynesMul = UnitMegadynesMul;
pub type Kilodynes<T> = Quantity<T, UnitKilodynes>;
#[allow(non_upper_case_globals)]
pub static Kilodynes: UnitKilodynesMul = UnitKilodynesMul;
pub type Hectodynes<T> = Quantity<T, UnitHectodynes>;
#[allow(non_upper_case_globals)]
pub static Hectodynes: UnitHectodynesMul = UnitHectodynesMul;
pub type Decadynes<T> = Quantity<T, UnitDecadynes>;
#[allow(non_upper_case_globals)]
pub static Decadynes: UnitDecadynesMul = UnitDecadynesMul;
pub type Decidynes<T> = Quantity<T, UnitDecidynes>;
#[allow(non_upper_case_globals)]
pub static Decidynes: UnitDecidynesMul = UnitDecidynesMul;
pub type Centidynes<T> = Quantity<T, UnitCentidynes>;
#[allow(non_upper_case_globals)]
pub static Centidynes: UnitCentidynesMul = UnitCentidynesMul;
pub type Millidynes<T> = Quantity<T, UnitMillidynes>;
#[allow(non_upper_case_globals)]
pub static Millidynes: UnitMillidynesMul = UnitMillidynesMul;
pub type Microdynes<T> = Quantity<T, UnitMicrodynes>;
#[allow(non_upper_case_globals)]
pub static Microdynes: UnitMicrodynesMul = UnitMicrodynesMul;
pub type Nanodynes<T> = Quantity<T, UnitNanodynes>;
#[allow(non_upper_case_globals)]
pub static Nanodynes: UnitNanodynesMul = UnitNanodynesMul;
pub type Picodynes<T> = Quantity<T, UnitPicodynes>;
#[allow(non_upper_case_globals)]
pub static Picodynes: UnitPicodynesMul = UnitPicodynesMul;
pub type Femtodynes<T> = Quantity<T, UnitFemtodynes>;
#[allow(non_upper_case_globals)]
pub static Femtodynes: UnitFemtodynesMul = UnitFemtodynesMul;
pub type Attodynes<T> = Quantity<T, UnitAttodynes>;
#[allow(non_upper_case_globals)]
pub static Attodynes: UnitAttodynesMul = UnitAttodynesMul;
pub type Zeptodynes<T> = Quantity<T, UnitZeptodynes>;
#[allow(non_upper_case_globals)]
pub static Zeptodynes: UnitZeptodynesMul = UnitZeptodynesMul;
pub type Yoctodynes<T> = Quantity<T, UnitYoctodynes>;
#[allow(non_upper_case_globals)]
pub static Yoctodynes: UnitYoctodynesMul = UnitYoctodynesMul;
pub type Rontodynes<T> = Quantity<T, UnitRontodynes>;
#[allow(non_upper_case_globals)]
pub static Rontodynes: UnitRontodynesMul = UnitRontodynesMul;
pub type Quectodynes<T> = Quantity<T, UnitQuectodynes>;
#[allow(non_upper_case_globals)]
pub static Quectodynes: UnitQuectodynesMul = UnitQuectodynesMul;
pub struct UnitBaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitBaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitBaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitBaryes {
    #[inline]
    fn clone(&self) -> UnitBaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitBaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitBaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitBaryes {
    #[inline]
    fn eq(&self, other: &UnitBaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitBaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitBaryes {
    fn default() -> Self {
        UnitBaryes
    }
}
impl Add<UnitBaryes> for UnitBaryes {
    type Output = UnitBaryes;
    #[inline]
    fn add(self, _: UnitBaryes) -> Self::Output {
        UnitBaryes
    }
}
impl AddAssign<UnitBaryes> for UnitBaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitBaryes) {}
}
impl Sub<UnitBaryes> for UnitBaryes {
    type Output = UnitBaryes;
    #[inline]
    fn sub(self, _: UnitBaryes) -> Self::Output {
        UnitBaryes
    }
}
impl SubAssign<UnitBaryes> for UnitBaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitBaryes) {}
}
pub struct UnitBaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitBaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitBaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitBaryesMul {
    #[inline]
    fn clone(&self) -> UnitBaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitBaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitBaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitBaryesMul {
    #[inline]
    fn eq(&self, other: &UnitBaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitBaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitBaryesMul> for i8 {
    type Output = Quantity<i8, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for i16 {
    type Output = Quantity<i16, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for i32 {
    type Output = Quantity<i32, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for i64 {
    type Output = Quantity<i64, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for i128 {
    type Output = Quantity<i128, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for isize {
    type Output = Quantity<isize, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for u8 {
    type Output = Quantity<u8, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for u16 {
    type Output = Quantity<u16, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for u32 {
    type Output = Quantity<u32, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for u64 {
    type Output = Quantity<u64, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for u128 {
    type Output = Quantity<u128, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for usize {
    type Output = Quantity<usize, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for f32 {
    type Output = Quantity<f32, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
impl Mul<UnitBaryesMul> for f64 {
    type Output = Quantity<f64, UnitBaryes>;
    fn mul(self, _: UnitBaryesMul) -> Self::Output {
        Quantity::new(self, UnitBaryes)
    }
}
pub struct UnitQuettabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettabaryes {
    #[inline]
    fn clone(&self) -> UnitQuettabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettabaryes {
    #[inline]
    fn eq(&self, other: &UnitQuettabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettabaryes {
    fn default() -> Self {
        UnitQuettabaryes
    }
}
impl Add<UnitQuettabaryes> for UnitQuettabaryes {
    type Output = UnitQuettabaryes;
    #[inline]
    fn add(self, _: UnitQuettabaryes) -> Self::Output {
        UnitQuettabaryes
    }
}
impl AddAssign<UnitQuettabaryes> for UnitQuettabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettabaryes) {}
}
impl Sub<UnitQuettabaryes> for UnitQuettabaryes {
    type Output = UnitQuettabaryes;
    #[inline]
    fn sub(self, _: UnitQuettabaryes) -> Self::Output {
        UnitQuettabaryes
    }
}
impl SubAssign<UnitQuettabaryes> for UnitQuettabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettabaryes) {}
}
pub struct UnitQuettabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettabaryesMul {
    #[inline]
    fn clone(&self) -> UnitQuettabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettabaryesMul> for i8 {
    type Output = Quantity<i8, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for i16 {
    type Output = Quantity<i16, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for i32 {
    type Output = Quantity<i32, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for i64 {
    type Output = Quantity<i64, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for i128 {
    type Output = Quantity<i128, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for isize {
    type Output = Quantity<isize, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for u8 {
    type Output = Quantity<u8, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for u16 {
    type Output = Quantity<u16, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for u32 {
    type Output = Quantity<u32, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for u64 {
    type Output = Quantity<u64, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for u128 {
    type Output = Quantity<u128, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for usize {
    type Output = Quantity<usize, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for f32 {
    type Output = Quantity<f32, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
impl Mul<UnitQuettabaryesMul> for f64 {
    type Output = Quantity<f64, UnitQuettabaryes>;
    fn mul(self, _: UnitQuettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuettabaryes)
    }
}
pub struct UnitRonnabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnabaryes {
    #[inline]
    fn clone(&self) -> UnitRonnabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnabaryes {
    #[inline]
    fn eq(&self, other: &UnitRonnabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnabaryes {
    fn default() -> Self {
        UnitRonnabaryes
    }
}
impl Add<UnitRonnabaryes> for UnitRonnabaryes {
    type Output = UnitRonnabaryes;
    #[inline]
    fn add(self, _: UnitRonnabaryes) -> Self::Output {
        UnitRonnabaryes
    }
}
impl AddAssign<UnitRonnabaryes> for UnitRonnabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnabaryes) {}
}
impl Sub<UnitRonnabaryes> for UnitRonnabaryes {
    type Output = UnitRonnabaryes;
    #[inline]
    fn sub(self, _: UnitRonnabaryes) -> Self::Output {
        UnitRonnabaryes
    }
}
impl SubAssign<UnitRonnabaryes> for UnitRonnabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnabaryes) {}
}
pub struct UnitRonnabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnabaryesMul {
    #[inline]
    fn clone(&self) -> UnitRonnabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnabaryesMul> for i8 {
    type Output = Quantity<i8, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for i16 {
    type Output = Quantity<i16, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for i32 {
    type Output = Quantity<i32, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for i64 {
    type Output = Quantity<i64, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for i128 {
    type Output = Quantity<i128, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for isize {
    type Output = Quantity<isize, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for u8 {
    type Output = Quantity<u8, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for u16 {
    type Output = Quantity<u16, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for u32 {
    type Output = Quantity<u32, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for u64 {
    type Output = Quantity<u64, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for u128 {
    type Output = Quantity<u128, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for usize {
    type Output = Quantity<usize, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for f32 {
    type Output = Quantity<f32, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
impl Mul<UnitRonnabaryesMul> for f64 {
    type Output = Quantity<f64, UnitRonnabaryes>;
    fn mul(self, _: UnitRonnabaryesMul) -> Self::Output {
        Quantity::new(self, UnitRonnabaryes)
    }
}
pub struct UnitYottabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottabaryes {
    #[inline]
    fn clone(&self) -> UnitYottabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottabaryes {
    #[inline]
    fn eq(&self, other: &UnitYottabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottabaryes {
    fn default() -> Self {
        UnitYottabaryes
    }
}
impl Add<UnitYottabaryes> for UnitYottabaryes {
    type Output = UnitYottabaryes;
    #[inline]
    fn add(self, _: UnitYottabaryes) -> Self::Output {
        UnitYottabaryes
    }
}
impl AddAssign<UnitYottabaryes> for UnitYottabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitYottabaryes) {}
}
impl Sub<UnitYottabaryes> for UnitYottabaryes {
    type Output = UnitYottabaryes;
    #[inline]
    fn sub(self, _: UnitYottabaryes) -> Self::Output {
        UnitYottabaryes
    }
}
impl SubAssign<UnitYottabaryes> for UnitYottabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottabaryes) {}
}
pub struct UnitYottabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottabaryesMul {
    #[inline]
    fn clone(&self) -> UnitYottabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitYottabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottabaryesMul> for i8 {
    type Output = Quantity<i8, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for i16 {
    type Output = Quantity<i16, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for i32 {
    type Output = Quantity<i32, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for i64 {
    type Output = Quantity<i64, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for i128 {
    type Output = Quantity<i128, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for isize {
    type Output = Quantity<isize, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for u8 {
    type Output = Quantity<u8, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for u16 {
    type Output = Quantity<u16, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for u32 {
    type Output = Quantity<u32, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for u64 {
    type Output = Quantity<u64, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for u128 {
    type Output = Quantity<u128, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for usize {
    type Output = Quantity<usize, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for f32 {
    type Output = Quantity<f32, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
impl Mul<UnitYottabaryesMul> for f64 {
    type Output = Quantity<f64, UnitYottabaryes>;
    fn mul(self, _: UnitYottabaryesMul) -> Self::Output {
        Quantity::new(self, UnitYottabaryes)
    }
}
pub struct UnitZettabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettabaryes {
    #[inline]
    fn clone(&self) -> UnitZettabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettabaryes {
    #[inline]
    fn eq(&self, other: &UnitZettabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettabaryes {
    fn default() -> Self {
        UnitZettabaryes
    }
}
impl Add<UnitZettabaryes> for UnitZettabaryes {
    type Output = UnitZettabaryes;
    #[inline]
    fn add(self, _: UnitZettabaryes) -> Self::Output {
        UnitZettabaryes
    }
}
impl AddAssign<UnitZettabaryes> for UnitZettabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitZettabaryes) {}
}
impl Sub<UnitZettabaryes> for UnitZettabaryes {
    type Output = UnitZettabaryes;
    #[inline]
    fn sub(self, _: UnitZettabaryes) -> Self::Output {
        UnitZettabaryes
    }
}
impl SubAssign<UnitZettabaryes> for UnitZettabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettabaryes) {}
}
pub struct UnitZettabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettabaryesMul {
    #[inline]
    fn clone(&self) -> UnitZettabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitZettabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettabaryesMul> for i8 {
    type Output = Quantity<i8, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for i16 {
    type Output = Quantity<i16, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for i32 {
    type Output = Quantity<i32, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for i64 {
    type Output = Quantity<i64, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for i128 {
    type Output = Quantity<i128, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for isize {
    type Output = Quantity<isize, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for u8 {
    type Output = Quantity<u8, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for u16 {
    type Output = Quantity<u16, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for u32 {
    type Output = Quantity<u32, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for u64 {
    type Output = Quantity<u64, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for u128 {
    type Output = Quantity<u128, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for usize {
    type Output = Quantity<usize, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for f32 {
    type Output = Quantity<f32, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
impl Mul<UnitZettabaryesMul> for f64 {
    type Output = Quantity<f64, UnitZettabaryes>;
    fn mul(self, _: UnitZettabaryesMul) -> Self::Output {
        Quantity::new(self, UnitZettabaryes)
    }
}
pub struct UnitExabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExabaryes {
    #[inline]
    fn clone(&self) -> UnitExabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExabaryes {
    #[inline]
    fn eq(&self, other: &UnitExabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExabaryes {
    fn default() -> Self {
        UnitExabaryes
    }
}
impl Add<UnitExabaryes> for UnitExabaryes {
    type Output = UnitExabaryes;
    #[inline]
    fn add(self, _: UnitExabaryes) -> Self::Output {
        UnitExabaryes
    }
}
impl AddAssign<UnitExabaryes> for UnitExabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitExabaryes) {}
}
impl Sub<UnitExabaryes> for UnitExabaryes {
    type Output = UnitExabaryes;
    #[inline]
    fn sub(self, _: UnitExabaryes) -> Self::Output {
        UnitExabaryes
    }
}
impl SubAssign<UnitExabaryes> for UnitExabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitExabaryes) {}
}
pub struct UnitExabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExabaryesMul {
    #[inline]
    fn clone(&self) -> UnitExabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitExabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExabaryesMul> for i8 {
    type Output = Quantity<i8, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for i16 {
    type Output = Quantity<i16, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for i32 {
    type Output = Quantity<i32, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for i64 {
    type Output = Quantity<i64, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for i128 {
    type Output = Quantity<i128, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for isize {
    type Output = Quantity<isize, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for u8 {
    type Output = Quantity<u8, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for u16 {
    type Output = Quantity<u16, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for u32 {
    type Output = Quantity<u32, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for u64 {
    type Output = Quantity<u64, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for u128 {
    type Output = Quantity<u128, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for usize {
    type Output = Quantity<usize, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for f32 {
    type Output = Quantity<f32, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
impl Mul<UnitExabaryesMul> for f64 {
    type Output = Quantity<f64, UnitExabaryes>;
    fn mul(self, _: UnitExabaryesMul) -> Self::Output {
        Quantity::new(self, UnitExabaryes)
    }
}
pub struct UnitPetabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetabaryes {
    #[inline]
    fn clone(&self) -> UnitPetabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetabaryes {
    #[inline]
    fn eq(&self, other: &UnitPetabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetabaryes {
    fn default() -> Self {
        UnitPetabaryes
    }
}
impl Add<UnitPetabaryes> for UnitPetabaryes {
    type Output = UnitPetabaryes;
    #[inline]
    fn add(self, _: UnitPetabaryes) -> Self::Output {
        UnitPetabaryes
    }
}
impl AddAssign<UnitPetabaryes> for UnitPetabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitPetabaryes) {}
}
impl Sub<UnitPetabaryes> for UnitPetabaryes {
    type Output = UnitPetabaryes;
    #[inline]
    fn sub(self, _: UnitPetabaryes) -> Self::Output {
        UnitPetabaryes
    }
}
impl SubAssign<UnitPetabaryes> for UnitPetabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetabaryes) {}
}
pub struct UnitPetabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetabaryesMul {
    #[inline]
    fn clone(&self) -> UnitPetabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitPetabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetabaryesMul> for i8 {
    type Output = Quantity<i8, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for i16 {
    type Output = Quantity<i16, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for i32 {
    type Output = Quantity<i32, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for i64 {
    type Output = Quantity<i64, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for i128 {
    type Output = Quantity<i128, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for isize {
    type Output = Quantity<isize, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for u8 {
    type Output = Quantity<u8, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for u16 {
    type Output = Quantity<u16, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for u32 {
    type Output = Quantity<u32, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for u64 {
    type Output = Quantity<u64, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for u128 {
    type Output = Quantity<u128, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for usize {
    type Output = Quantity<usize, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for f32 {
    type Output = Quantity<f32, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
impl Mul<UnitPetabaryesMul> for f64 {
    type Output = Quantity<f64, UnitPetabaryes>;
    fn mul(self, _: UnitPetabaryesMul) -> Self::Output {
        Quantity::new(self, UnitPetabaryes)
    }
}
pub struct UnitTerabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerabaryes {
    #[inline]
    fn clone(&self) -> UnitTerabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerabaryes {
    #[inline]
    fn eq(&self, other: &UnitTerabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerabaryes {
    fn default() -> Self {
        UnitTerabaryes
    }
}
impl Add<UnitTerabaryes> for UnitTerabaryes {
    type Output = UnitTerabaryes;
    #[inline]
    fn add(self, _: UnitTerabaryes) -> Self::Output {
        UnitTerabaryes
    }
}
impl AddAssign<UnitTerabaryes> for UnitTerabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitTerabaryes) {}
}
impl Sub<UnitTerabaryes> for UnitTerabaryes {
    type Output = UnitTerabaryes;
    #[inline]
    fn sub(self, _: UnitTerabaryes) -> Self::Output {
        UnitTerabaryes
    }
}
impl SubAssign<UnitTerabaryes> for UnitTerabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerabaryes) {}
}
pub struct UnitTerabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerabaryesMul {
    #[inline]
    fn clone(&self) -> UnitTerabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitTerabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerabaryesMul> for i8 {
    type Output = Quantity<i8, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for i16 {
    type Output = Quantity<i16, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for i32 {
    type Output = Quantity<i32, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for i64 {
    type Output = Quantity<i64, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for i128 {
    type Output = Quantity<i128, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for isize {
    type Output = Quantity<isize, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for u8 {
    type Output = Quantity<u8, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for u16 {
    type Output = Quantity<u16, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for u32 {
    type Output = Quantity<u32, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for u64 {
    type Output = Quantity<u64, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for u128 {
    type Output = Quantity<u128, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for usize {
    type Output = Quantity<usize, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for f32 {
    type Output = Quantity<f32, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
impl Mul<UnitTerabaryesMul> for f64 {
    type Output = Quantity<f64, UnitTerabaryes>;
    fn mul(self, _: UnitTerabaryesMul) -> Self::Output {
        Quantity::new(self, UnitTerabaryes)
    }
}
pub struct UnitGigabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigabaryes {
    #[inline]
    fn clone(&self) -> UnitGigabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigabaryes {
    #[inline]
    fn eq(&self, other: &UnitGigabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigabaryes {
    fn default() -> Self {
        UnitGigabaryes
    }
}
impl Add<UnitGigabaryes> for UnitGigabaryes {
    type Output = UnitGigabaryes;
    #[inline]
    fn add(self, _: UnitGigabaryes) -> Self::Output {
        UnitGigabaryes
    }
}
impl AddAssign<UnitGigabaryes> for UnitGigabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitGigabaryes) {}
}
impl Sub<UnitGigabaryes> for UnitGigabaryes {
    type Output = UnitGigabaryes;
    #[inline]
    fn sub(self, _: UnitGigabaryes) -> Self::Output {
        UnitGigabaryes
    }
}
impl SubAssign<UnitGigabaryes> for UnitGigabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigabaryes) {}
}
pub struct UnitGigabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigabaryesMul {
    #[inline]
    fn clone(&self) -> UnitGigabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitGigabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigabaryesMul> for i8 {
    type Output = Quantity<i8, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for i16 {
    type Output = Quantity<i16, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for i32 {
    type Output = Quantity<i32, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for i64 {
    type Output = Quantity<i64, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for i128 {
    type Output = Quantity<i128, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for isize {
    type Output = Quantity<isize, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for u8 {
    type Output = Quantity<u8, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for u16 {
    type Output = Quantity<u16, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for u32 {
    type Output = Quantity<u32, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for u64 {
    type Output = Quantity<u64, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for u128 {
    type Output = Quantity<u128, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for usize {
    type Output = Quantity<usize, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for f32 {
    type Output = Quantity<f32, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
impl Mul<UnitGigabaryesMul> for f64 {
    type Output = Quantity<f64, UnitGigabaryes>;
    fn mul(self, _: UnitGigabaryesMul) -> Self::Output {
        Quantity::new(self, UnitGigabaryes)
    }
}
pub struct UnitMegabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegabaryes {
    #[inline]
    fn clone(&self) -> UnitMegabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegabaryes {
    #[inline]
    fn eq(&self, other: &UnitMegabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegabaryes {
    fn default() -> Self {
        UnitMegabaryes
    }
}
impl Add<UnitMegabaryes> for UnitMegabaryes {
    type Output = UnitMegabaryes;
    #[inline]
    fn add(self, _: UnitMegabaryes) -> Self::Output {
        UnitMegabaryes
    }
}
impl AddAssign<UnitMegabaryes> for UnitMegabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitMegabaryes) {}
}
impl Sub<UnitMegabaryes> for UnitMegabaryes {
    type Output = UnitMegabaryes;
    #[inline]
    fn sub(self, _: UnitMegabaryes) -> Self::Output {
        UnitMegabaryes
    }
}
impl SubAssign<UnitMegabaryes> for UnitMegabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegabaryes) {}
}
pub struct UnitMegabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegabaryesMul {
    #[inline]
    fn clone(&self) -> UnitMegabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitMegabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegabaryesMul> for i8 {
    type Output = Quantity<i8, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for i16 {
    type Output = Quantity<i16, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for i32 {
    type Output = Quantity<i32, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for i64 {
    type Output = Quantity<i64, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for i128 {
    type Output = Quantity<i128, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for isize {
    type Output = Quantity<isize, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for u8 {
    type Output = Quantity<u8, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for u16 {
    type Output = Quantity<u16, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for u32 {
    type Output = Quantity<u32, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for u64 {
    type Output = Quantity<u64, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for u128 {
    type Output = Quantity<u128, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for usize {
    type Output = Quantity<usize, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for f32 {
    type Output = Quantity<f32, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
impl Mul<UnitMegabaryesMul> for f64 {
    type Output = Quantity<f64, UnitMegabaryes>;
    fn mul(self, _: UnitMegabaryesMul) -> Self::Output {
        Quantity::new(self, UnitMegabaryes)
    }
}
pub struct UnitKilobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilobaryes {
    #[inline]
    fn clone(&self) -> UnitKilobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilobaryes {
    #[inline]
    fn eq(&self, other: &UnitKilobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilobaryes {
    fn default() -> Self {
        UnitKilobaryes
    }
}
impl Add<UnitKilobaryes> for UnitKilobaryes {
    type Output = UnitKilobaryes;
    #[inline]
    fn add(self, _: UnitKilobaryes) -> Self::Output {
        UnitKilobaryes
    }
}
impl AddAssign<UnitKilobaryes> for UnitKilobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitKilobaryes) {}
}
impl Sub<UnitKilobaryes> for UnitKilobaryes {
    type Output = UnitKilobaryes;
    #[inline]
    fn sub(self, _: UnitKilobaryes) -> Self::Output {
        UnitKilobaryes
    }
}
impl SubAssign<UnitKilobaryes> for UnitKilobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilobaryes) {}
}
pub struct UnitKilobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilobaryesMul {
    #[inline]
    fn clone(&self) -> UnitKilobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitKilobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilobaryesMul> for i8 {
    type Output = Quantity<i8, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for i16 {
    type Output = Quantity<i16, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for i32 {
    type Output = Quantity<i32, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for i64 {
    type Output = Quantity<i64, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for i128 {
    type Output = Quantity<i128, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for isize {
    type Output = Quantity<isize, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for u8 {
    type Output = Quantity<u8, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for u16 {
    type Output = Quantity<u16, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for u32 {
    type Output = Quantity<u32, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for u64 {
    type Output = Quantity<u64, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for u128 {
    type Output = Quantity<u128, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for usize {
    type Output = Quantity<usize, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for f32 {
    type Output = Quantity<f32, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
impl Mul<UnitKilobaryesMul> for f64 {
    type Output = Quantity<f64, UnitKilobaryes>;
    fn mul(self, _: UnitKilobaryesMul) -> Self::Output {
        Quantity::new(self, UnitKilobaryes)
    }
}
pub struct UnitHectobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectobaryes {
    #[inline]
    fn clone(&self) -> UnitHectobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectobaryes {
    #[inline]
    fn eq(&self, other: &UnitHectobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectobaryes {
    fn default() -> Self {
        UnitHectobaryes
    }
}
impl Add<UnitHectobaryes> for UnitHectobaryes {
    type Output = UnitHectobaryes;
    #[inline]
    fn add(self, _: UnitHectobaryes) -> Self::Output {
        UnitHectobaryes
    }
}
impl AddAssign<UnitHectobaryes> for UnitHectobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitHectobaryes) {}
}
impl Sub<UnitHectobaryes> for UnitHectobaryes {
    type Output = UnitHectobaryes;
    #[inline]
    fn sub(self, _: UnitHectobaryes) -> Self::Output {
        UnitHectobaryes
    }
}
impl SubAssign<UnitHectobaryes> for UnitHectobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectobaryes) {}
}
pub struct UnitHectobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectobaryesMul {
    #[inline]
    fn clone(&self) -> UnitHectobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitHectobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectobaryesMul> for i8 {
    type Output = Quantity<i8, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for i16 {
    type Output = Quantity<i16, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for i32 {
    type Output = Quantity<i32, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for i64 {
    type Output = Quantity<i64, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for i128 {
    type Output = Quantity<i128, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for isize {
    type Output = Quantity<isize, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for u8 {
    type Output = Quantity<u8, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for u16 {
    type Output = Quantity<u16, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for u32 {
    type Output = Quantity<u32, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for u64 {
    type Output = Quantity<u64, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for u128 {
    type Output = Quantity<u128, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for usize {
    type Output = Quantity<usize, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for f32 {
    type Output = Quantity<f32, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
impl Mul<UnitHectobaryesMul> for f64 {
    type Output = Quantity<f64, UnitHectobaryes>;
    fn mul(self, _: UnitHectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitHectobaryes)
    }
}
pub struct UnitDecabaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecabaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecabaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecabaryes {
    #[inline]
    fn clone(&self) -> UnitDecabaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecabaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecabaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecabaryes {
    #[inline]
    fn eq(&self, other: &UnitDecabaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecabaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecabaryes {
    fn default() -> Self {
        UnitDecabaryes
    }
}
impl Add<UnitDecabaryes> for UnitDecabaryes {
    type Output = UnitDecabaryes;
    #[inline]
    fn add(self, _: UnitDecabaryes) -> Self::Output {
        UnitDecabaryes
    }
}
impl AddAssign<UnitDecabaryes> for UnitDecabaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecabaryes) {}
}
impl Sub<UnitDecabaryes> for UnitDecabaryes {
    type Output = UnitDecabaryes;
    #[inline]
    fn sub(self, _: UnitDecabaryes) -> Self::Output {
        UnitDecabaryes
    }
}
impl SubAssign<UnitDecabaryes> for UnitDecabaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecabaryes) {}
}
pub struct UnitDecabaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecabaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecabaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecabaryesMul {
    #[inline]
    fn clone(&self) -> UnitDecabaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecabaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecabaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecabaryesMul {
    #[inline]
    fn eq(&self, other: &UnitDecabaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecabaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecabaryesMul> for i8 {
    type Output = Quantity<i8, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for i16 {
    type Output = Quantity<i16, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for i32 {
    type Output = Quantity<i32, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for i64 {
    type Output = Quantity<i64, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for i128 {
    type Output = Quantity<i128, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for isize {
    type Output = Quantity<isize, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for u8 {
    type Output = Quantity<u8, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for u16 {
    type Output = Quantity<u16, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for u32 {
    type Output = Quantity<u32, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for u64 {
    type Output = Quantity<u64, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for u128 {
    type Output = Quantity<u128, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for usize {
    type Output = Quantity<usize, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for f32 {
    type Output = Quantity<f32, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
impl Mul<UnitDecabaryesMul> for f64 {
    type Output = Quantity<f64, UnitDecabaryes>;
    fn mul(self, _: UnitDecabaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecabaryes)
    }
}
pub struct UnitDecibaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecibaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecibaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecibaryes {
    #[inline]
    fn clone(&self) -> UnitDecibaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecibaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecibaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecibaryes {
    #[inline]
    fn eq(&self, other: &UnitDecibaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecibaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecibaryes {
    fn default() -> Self {
        UnitDecibaryes
    }
}
impl Add<UnitDecibaryes> for UnitDecibaryes {
    type Output = UnitDecibaryes;
    #[inline]
    fn add(self, _: UnitDecibaryes) -> Self::Output {
        UnitDecibaryes
    }
}
impl AddAssign<UnitDecibaryes> for UnitDecibaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecibaryes) {}
}
impl Sub<UnitDecibaryes> for UnitDecibaryes {
    type Output = UnitDecibaryes;
    #[inline]
    fn sub(self, _: UnitDecibaryes) -> Self::Output {
        UnitDecibaryes
    }
}
impl SubAssign<UnitDecibaryes> for UnitDecibaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecibaryes) {}
}
pub struct UnitDecibaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecibaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecibaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecibaryesMul {
    #[inline]
    fn clone(&self) -> UnitDecibaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecibaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecibaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecibaryesMul {
    #[inline]
    fn eq(&self, other: &UnitDecibaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecibaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecibaryesMul> for i8 {
    type Output = Quantity<i8, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for i16 {
    type Output = Quantity<i16, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for i32 {
    type Output = Quantity<i32, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for i64 {
    type Output = Quantity<i64, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for i128 {
    type Output = Quantity<i128, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for isize {
    type Output = Quantity<isize, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for u8 {
    type Output = Quantity<u8, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for u16 {
    type Output = Quantity<u16, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for u32 {
    type Output = Quantity<u32, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for u64 {
    type Output = Quantity<u64, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for u128 {
    type Output = Quantity<u128, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for usize {
    type Output = Quantity<usize, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for f32 {
    type Output = Quantity<f32, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
impl Mul<UnitDecibaryesMul> for f64 {
    type Output = Quantity<f64, UnitDecibaryes>;
    fn mul(self, _: UnitDecibaryesMul) -> Self::Output {
        Quantity::new(self, UnitDecibaryes)
    }
}
pub struct UnitCentibaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentibaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentibaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentibaryes {
    #[inline]
    fn clone(&self) -> UnitCentibaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentibaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentibaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentibaryes {
    #[inline]
    fn eq(&self, other: &UnitCentibaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentibaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentibaryes {
    fn default() -> Self {
        UnitCentibaryes
    }
}
impl Add<UnitCentibaryes> for UnitCentibaryes {
    type Output = UnitCentibaryes;
    #[inline]
    fn add(self, _: UnitCentibaryes) -> Self::Output {
        UnitCentibaryes
    }
}
impl AddAssign<UnitCentibaryes> for UnitCentibaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitCentibaryes) {}
}
impl Sub<UnitCentibaryes> for UnitCentibaryes {
    type Output = UnitCentibaryes;
    #[inline]
    fn sub(self, _: UnitCentibaryes) -> Self::Output {
        UnitCentibaryes
    }
}
impl SubAssign<UnitCentibaryes> for UnitCentibaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentibaryes) {}
}
pub struct UnitCentibaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentibaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentibaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentibaryesMul {
    #[inline]
    fn clone(&self) -> UnitCentibaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentibaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentibaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentibaryesMul {
    #[inline]
    fn eq(&self, other: &UnitCentibaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentibaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentibaryesMul> for i8 {
    type Output = Quantity<i8, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for i16 {
    type Output = Quantity<i16, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for i32 {
    type Output = Quantity<i32, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for i64 {
    type Output = Quantity<i64, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for i128 {
    type Output = Quantity<i128, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for isize {
    type Output = Quantity<isize, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for u8 {
    type Output = Quantity<u8, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for u16 {
    type Output = Quantity<u16, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for u32 {
    type Output = Quantity<u32, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for u64 {
    type Output = Quantity<u64, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for u128 {
    type Output = Quantity<u128, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for usize {
    type Output = Quantity<usize, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for f32 {
    type Output = Quantity<f32, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
impl Mul<UnitCentibaryesMul> for f64 {
    type Output = Quantity<f64, UnitCentibaryes>;
    fn mul(self, _: UnitCentibaryesMul) -> Self::Output {
        Quantity::new(self, UnitCentibaryes)
    }
}
pub struct UnitMillibaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillibaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillibaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillibaryes {
    #[inline]
    fn clone(&self) -> UnitMillibaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillibaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillibaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillibaryes {
    #[inline]
    fn eq(&self, other: &UnitMillibaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillibaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillibaryes {
    fn default() -> Self {
        UnitMillibaryes
    }
}
impl Add<UnitMillibaryes> for UnitMillibaryes {
    type Output = UnitMillibaryes;
    #[inline]
    fn add(self, _: UnitMillibaryes) -> Self::Output {
        UnitMillibaryes
    }
}
impl AddAssign<UnitMillibaryes> for UnitMillibaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitMillibaryes) {}
}
impl Sub<UnitMillibaryes> for UnitMillibaryes {
    type Output = UnitMillibaryes;
    #[inline]
    fn sub(self, _: UnitMillibaryes) -> Self::Output {
        UnitMillibaryes
    }
}
impl SubAssign<UnitMillibaryes> for UnitMillibaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillibaryes) {}
}
pub struct UnitMillibaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillibaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillibaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillibaryesMul {
    #[inline]
    fn clone(&self) -> UnitMillibaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillibaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillibaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillibaryesMul {
    #[inline]
    fn eq(&self, other: &UnitMillibaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillibaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillibaryesMul> for i8 {
    type Output = Quantity<i8, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for i16 {
    type Output = Quantity<i16, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for i32 {
    type Output = Quantity<i32, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for i64 {
    type Output = Quantity<i64, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for i128 {
    type Output = Quantity<i128, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for isize {
    type Output = Quantity<isize, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for u8 {
    type Output = Quantity<u8, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for u16 {
    type Output = Quantity<u16, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for u32 {
    type Output = Quantity<u32, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for u64 {
    type Output = Quantity<u64, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for u128 {
    type Output = Quantity<u128, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for usize {
    type Output = Quantity<usize, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for f32 {
    type Output = Quantity<f32, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
impl Mul<UnitMillibaryesMul> for f64 {
    type Output = Quantity<f64, UnitMillibaryes>;
    fn mul(self, _: UnitMillibaryesMul) -> Self::Output {
        Quantity::new(self, UnitMillibaryes)
    }
}
pub struct UnitMicrobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrobaryes {
    #[inline]
    fn clone(&self) -> UnitMicrobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrobaryes {
    #[inline]
    fn eq(&self, other: &UnitMicrobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrobaryes {
    fn default() -> Self {
        UnitMicrobaryes
    }
}
impl Add<UnitMicrobaryes> for UnitMicrobaryes {
    type Output = UnitMicrobaryes;
    #[inline]
    fn add(self, _: UnitMicrobaryes) -> Self::Output {
        UnitMicrobaryes
    }
}
impl AddAssign<UnitMicrobaryes> for UnitMicrobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrobaryes) {}
}
impl Sub<UnitMicrobaryes> for UnitMicrobaryes {
    type Output = UnitMicrobaryes;
    #[inline]
    fn sub(self, _: UnitMicrobaryes) -> Self::Output {
        UnitMicrobaryes
    }
}
impl SubAssign<UnitMicrobaryes> for UnitMicrobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrobaryes) {}
}
pub struct UnitMicrobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrobaryesMul {
    #[inline]
    fn clone(&self) -> UnitMicrobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitMicrobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrobaryesMul> for i8 {
    type Output = Quantity<i8, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for i16 {
    type Output = Quantity<i16, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for i32 {
    type Output = Quantity<i32, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for i64 {
    type Output = Quantity<i64, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for i128 {
    type Output = Quantity<i128, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for isize {
    type Output = Quantity<isize, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for u8 {
    type Output = Quantity<u8, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for u16 {
    type Output = Quantity<u16, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for u32 {
    type Output = Quantity<u32, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for u64 {
    type Output = Quantity<u64, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for u128 {
    type Output = Quantity<u128, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for usize {
    type Output = Quantity<usize, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for f32 {
    type Output = Quantity<f32, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
impl Mul<UnitMicrobaryesMul> for f64 {
    type Output = Quantity<f64, UnitMicrobaryes>;
    fn mul(self, _: UnitMicrobaryesMul) -> Self::Output {
        Quantity::new(self, UnitMicrobaryes)
    }
}
pub struct UnitNanobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanobaryes {
    #[inline]
    fn clone(&self) -> UnitNanobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanobaryes {
    #[inline]
    fn eq(&self, other: &UnitNanobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanobaryes {
    fn default() -> Self {
        UnitNanobaryes
    }
}
impl Add<UnitNanobaryes> for UnitNanobaryes {
    type Output = UnitNanobaryes;
    #[inline]
    fn add(self, _: UnitNanobaryes) -> Self::Output {
        UnitNanobaryes
    }
}
impl AddAssign<UnitNanobaryes> for UnitNanobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitNanobaryes) {}
}
impl Sub<UnitNanobaryes> for UnitNanobaryes {
    type Output = UnitNanobaryes;
    #[inline]
    fn sub(self, _: UnitNanobaryes) -> Self::Output {
        UnitNanobaryes
    }
}
impl SubAssign<UnitNanobaryes> for UnitNanobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanobaryes) {}
}
pub struct UnitNanobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanobaryesMul {
    #[inline]
    fn clone(&self) -> UnitNanobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitNanobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanobaryesMul> for i8 {
    type Output = Quantity<i8, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for i16 {
    type Output = Quantity<i16, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for i32 {
    type Output = Quantity<i32, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for i64 {
    type Output = Quantity<i64, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for i128 {
    type Output = Quantity<i128, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for isize {
    type Output = Quantity<isize, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for u8 {
    type Output = Quantity<u8, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for u16 {
    type Output = Quantity<u16, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for u32 {
    type Output = Quantity<u32, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for u64 {
    type Output = Quantity<u64, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for u128 {
    type Output = Quantity<u128, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for usize {
    type Output = Quantity<usize, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for f32 {
    type Output = Quantity<f32, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
impl Mul<UnitNanobaryesMul> for f64 {
    type Output = Quantity<f64, UnitNanobaryes>;
    fn mul(self, _: UnitNanobaryesMul) -> Self::Output {
        Quantity::new(self, UnitNanobaryes)
    }
}
pub struct UnitPicobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicobaryes {
    #[inline]
    fn clone(&self) -> UnitPicobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicobaryes {
    #[inline]
    fn eq(&self, other: &UnitPicobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicobaryes {
    fn default() -> Self {
        UnitPicobaryes
    }
}
impl Add<UnitPicobaryes> for UnitPicobaryes {
    type Output = UnitPicobaryes;
    #[inline]
    fn add(self, _: UnitPicobaryes) -> Self::Output {
        UnitPicobaryes
    }
}
impl AddAssign<UnitPicobaryes> for UnitPicobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitPicobaryes) {}
}
impl Sub<UnitPicobaryes> for UnitPicobaryes {
    type Output = UnitPicobaryes;
    #[inline]
    fn sub(self, _: UnitPicobaryes) -> Self::Output {
        UnitPicobaryes
    }
}
impl SubAssign<UnitPicobaryes> for UnitPicobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicobaryes) {}
}
pub struct UnitPicobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicobaryesMul {
    #[inline]
    fn clone(&self) -> UnitPicobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitPicobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicobaryesMul> for i8 {
    type Output = Quantity<i8, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for i16 {
    type Output = Quantity<i16, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for i32 {
    type Output = Quantity<i32, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for i64 {
    type Output = Quantity<i64, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for i128 {
    type Output = Quantity<i128, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for isize {
    type Output = Quantity<isize, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for u8 {
    type Output = Quantity<u8, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for u16 {
    type Output = Quantity<u16, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for u32 {
    type Output = Quantity<u32, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for u64 {
    type Output = Quantity<u64, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for u128 {
    type Output = Quantity<u128, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for usize {
    type Output = Quantity<usize, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for f32 {
    type Output = Quantity<f32, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
impl Mul<UnitPicobaryesMul> for f64 {
    type Output = Quantity<f64, UnitPicobaryes>;
    fn mul(self, _: UnitPicobaryesMul) -> Self::Output {
        Quantity::new(self, UnitPicobaryes)
    }
}
pub struct UnitFemtobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtobaryes {
    #[inline]
    fn clone(&self) -> UnitFemtobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtobaryes {
    #[inline]
    fn eq(&self, other: &UnitFemtobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtobaryes {
    fn default() -> Self {
        UnitFemtobaryes
    }
}
impl Add<UnitFemtobaryes> for UnitFemtobaryes {
    type Output = UnitFemtobaryes;
    #[inline]
    fn add(self, _: UnitFemtobaryes) -> Self::Output {
        UnitFemtobaryes
    }
}
impl AddAssign<UnitFemtobaryes> for UnitFemtobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtobaryes) {}
}
impl Sub<UnitFemtobaryes> for UnitFemtobaryes {
    type Output = UnitFemtobaryes;
    #[inline]
    fn sub(self, _: UnitFemtobaryes) -> Self::Output {
        UnitFemtobaryes
    }
}
impl SubAssign<UnitFemtobaryes> for UnitFemtobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtobaryes) {}
}
pub struct UnitFemtobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtobaryesMul {
    #[inline]
    fn clone(&self) -> UnitFemtobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtobaryesMul> for i8 {
    type Output = Quantity<i8, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for i16 {
    type Output = Quantity<i16, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for i32 {
    type Output = Quantity<i32, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for i64 {
    type Output = Quantity<i64, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for i128 {
    type Output = Quantity<i128, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for isize {
    type Output = Quantity<isize, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for u8 {
    type Output = Quantity<u8, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for u16 {
    type Output = Quantity<u16, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for u32 {
    type Output = Quantity<u32, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for u64 {
    type Output = Quantity<u64, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for u128 {
    type Output = Quantity<u128, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for usize {
    type Output = Quantity<usize, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for f32 {
    type Output = Quantity<f32, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
impl Mul<UnitFemtobaryesMul> for f64 {
    type Output = Quantity<f64, UnitFemtobaryes>;
    fn mul(self, _: UnitFemtobaryesMul) -> Self::Output {
        Quantity::new(self, UnitFemtobaryes)
    }
}
pub struct UnitAttobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttobaryes {
    #[inline]
    fn clone(&self) -> UnitAttobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttobaryes {
    #[inline]
    fn eq(&self, other: &UnitAttobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttobaryes {
    fn default() -> Self {
        UnitAttobaryes
    }
}
impl Add<UnitAttobaryes> for UnitAttobaryes {
    type Output = UnitAttobaryes;
    #[inline]
    fn add(self, _: UnitAttobaryes) -> Self::Output {
        UnitAttobaryes
    }
}
impl AddAssign<UnitAttobaryes> for UnitAttobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitAttobaryes) {}
}
impl Sub<UnitAttobaryes> for UnitAttobaryes {
    type Output = UnitAttobaryes;
    #[inline]
    fn sub(self, _: UnitAttobaryes) -> Self::Output {
        UnitAttobaryes
    }
}
impl SubAssign<UnitAttobaryes> for UnitAttobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttobaryes) {}
}
pub struct UnitAttobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttobaryesMul {
    #[inline]
    fn clone(&self) -> UnitAttobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitAttobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttobaryesMul> for i8 {
    type Output = Quantity<i8, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for i16 {
    type Output = Quantity<i16, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for i32 {
    type Output = Quantity<i32, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for i64 {
    type Output = Quantity<i64, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for i128 {
    type Output = Quantity<i128, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for isize {
    type Output = Quantity<isize, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for u8 {
    type Output = Quantity<u8, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for u16 {
    type Output = Quantity<u16, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for u32 {
    type Output = Quantity<u32, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for u64 {
    type Output = Quantity<u64, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for u128 {
    type Output = Quantity<u128, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for usize {
    type Output = Quantity<usize, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for f32 {
    type Output = Quantity<f32, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
impl Mul<UnitAttobaryesMul> for f64 {
    type Output = Quantity<f64, UnitAttobaryes>;
    fn mul(self, _: UnitAttobaryesMul) -> Self::Output {
        Quantity::new(self, UnitAttobaryes)
    }
}
pub struct UnitZeptobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptobaryes {
    #[inline]
    fn clone(&self) -> UnitZeptobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptobaryes {
    #[inline]
    fn eq(&self, other: &UnitZeptobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptobaryes {
    fn default() -> Self {
        UnitZeptobaryes
    }
}
impl Add<UnitZeptobaryes> for UnitZeptobaryes {
    type Output = UnitZeptobaryes;
    #[inline]
    fn add(self, _: UnitZeptobaryes) -> Self::Output {
        UnitZeptobaryes
    }
}
impl AddAssign<UnitZeptobaryes> for UnitZeptobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptobaryes) {}
}
impl Sub<UnitZeptobaryes> for UnitZeptobaryes {
    type Output = UnitZeptobaryes;
    #[inline]
    fn sub(self, _: UnitZeptobaryes) -> Self::Output {
        UnitZeptobaryes
    }
}
impl SubAssign<UnitZeptobaryes> for UnitZeptobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptobaryes) {}
}
pub struct UnitZeptobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptobaryesMul {
    #[inline]
    fn clone(&self) -> UnitZeptobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptobaryesMul> for i8 {
    type Output = Quantity<i8, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for i16 {
    type Output = Quantity<i16, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for i32 {
    type Output = Quantity<i32, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for i64 {
    type Output = Quantity<i64, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for i128 {
    type Output = Quantity<i128, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for isize {
    type Output = Quantity<isize, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for u8 {
    type Output = Quantity<u8, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for u16 {
    type Output = Quantity<u16, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for u32 {
    type Output = Quantity<u32, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for u64 {
    type Output = Quantity<u64, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for u128 {
    type Output = Quantity<u128, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for usize {
    type Output = Quantity<usize, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for f32 {
    type Output = Quantity<f32, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
impl Mul<UnitZeptobaryesMul> for f64 {
    type Output = Quantity<f64, UnitZeptobaryes>;
    fn mul(self, _: UnitZeptobaryesMul) -> Self::Output {
        Quantity::new(self, UnitZeptobaryes)
    }
}
pub struct UnitYoctobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctobaryes {
    #[inline]
    fn clone(&self) -> UnitYoctobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctobaryes {
    #[inline]
    fn eq(&self, other: &UnitYoctobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctobaryes {
    fn default() -> Self {
        UnitYoctobaryes
    }
}
impl Add<UnitYoctobaryes> for UnitYoctobaryes {
    type Output = UnitYoctobaryes;
    #[inline]
    fn add(self, _: UnitYoctobaryes) -> Self::Output {
        UnitYoctobaryes
    }
}
impl AddAssign<UnitYoctobaryes> for UnitYoctobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctobaryes) {}
}
impl Sub<UnitYoctobaryes> for UnitYoctobaryes {
    type Output = UnitYoctobaryes;
    #[inline]
    fn sub(self, _: UnitYoctobaryes) -> Self::Output {
        UnitYoctobaryes
    }
}
impl SubAssign<UnitYoctobaryes> for UnitYoctobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctobaryes) {}
}
pub struct UnitYoctobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctobaryesMul {
    #[inline]
    fn clone(&self) -> UnitYoctobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctobaryesMul> for i8 {
    type Output = Quantity<i8, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for i16 {
    type Output = Quantity<i16, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for i32 {
    type Output = Quantity<i32, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for i64 {
    type Output = Quantity<i64, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for i128 {
    type Output = Quantity<i128, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for isize {
    type Output = Quantity<isize, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for u8 {
    type Output = Quantity<u8, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for u16 {
    type Output = Quantity<u16, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for u32 {
    type Output = Quantity<u32, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for u64 {
    type Output = Quantity<u64, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for u128 {
    type Output = Quantity<u128, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for usize {
    type Output = Quantity<usize, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for f32 {
    type Output = Quantity<f32, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
impl Mul<UnitYoctobaryesMul> for f64 {
    type Output = Quantity<f64, UnitYoctobaryes>;
    fn mul(self, _: UnitYoctobaryesMul) -> Self::Output {
        Quantity::new(self, UnitYoctobaryes)
    }
}
pub struct UnitRontobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontobaryes {
    #[inline]
    fn clone(&self) -> UnitRontobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontobaryes {
    #[inline]
    fn eq(&self, other: &UnitRontobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontobaryes {
    fn default() -> Self {
        UnitRontobaryes
    }
}
impl Add<UnitRontobaryes> for UnitRontobaryes {
    type Output = UnitRontobaryes;
    #[inline]
    fn add(self, _: UnitRontobaryes) -> Self::Output {
        UnitRontobaryes
    }
}
impl AddAssign<UnitRontobaryes> for UnitRontobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitRontobaryes) {}
}
impl Sub<UnitRontobaryes> for UnitRontobaryes {
    type Output = UnitRontobaryes;
    #[inline]
    fn sub(self, _: UnitRontobaryes) -> Self::Output {
        UnitRontobaryes
    }
}
impl SubAssign<UnitRontobaryes> for UnitRontobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontobaryes) {}
}
pub struct UnitRontobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontobaryesMul {
    #[inline]
    fn clone(&self) -> UnitRontobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitRontobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontobaryesMul> for i8 {
    type Output = Quantity<i8, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for i16 {
    type Output = Quantity<i16, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for i32 {
    type Output = Quantity<i32, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for i64 {
    type Output = Quantity<i64, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for i128 {
    type Output = Quantity<i128, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for isize {
    type Output = Quantity<isize, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for u8 {
    type Output = Quantity<u8, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for u16 {
    type Output = Quantity<u16, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for u32 {
    type Output = Quantity<u32, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for u64 {
    type Output = Quantity<u64, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for u128 {
    type Output = Quantity<u128, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for usize {
    type Output = Quantity<usize, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for f32 {
    type Output = Quantity<f32, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
impl Mul<UnitRontobaryesMul> for f64 {
    type Output = Quantity<f64, UnitRontobaryes>;
    fn mul(self, _: UnitRontobaryesMul) -> Self::Output {
        Quantity::new(self, UnitRontobaryes)
    }
}
pub struct UnitQuectobaryes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectobaryes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectobaryes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectobaryes {
    #[inline]
    fn clone(&self) -> UnitQuectobaryes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectobaryes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectobaryes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectobaryes {
    #[inline]
    fn eq(&self, other: &UnitQuectobaryes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectobaryes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectobaryes {
    fn default() -> Self {
        UnitQuectobaryes
    }
}
impl Add<UnitQuectobaryes> for UnitQuectobaryes {
    type Output = UnitQuectobaryes;
    #[inline]
    fn add(self, _: UnitQuectobaryes) -> Self::Output {
        UnitQuectobaryes
    }
}
impl AddAssign<UnitQuectobaryes> for UnitQuectobaryes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectobaryes) {}
}
impl Sub<UnitQuectobaryes> for UnitQuectobaryes {
    type Output = UnitQuectobaryes;
    #[inline]
    fn sub(self, _: UnitQuectobaryes) -> Self::Output {
        UnitQuectobaryes
    }
}
impl SubAssign<UnitQuectobaryes> for UnitQuectobaryes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectobaryes) {}
}
pub struct UnitQuectobaryesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectobaryesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectobaryesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectobaryesMul {
    #[inline]
    fn clone(&self) -> UnitQuectobaryesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectobaryesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectobaryesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectobaryesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectobaryesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectobaryesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectobaryesMul> for i8 {
    type Output = Quantity<i8, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for i16 {
    type Output = Quantity<i16, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for i32 {
    type Output = Quantity<i32, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for i64 {
    type Output = Quantity<i64, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for i128 {
    type Output = Quantity<i128, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for isize {
    type Output = Quantity<isize, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for u8 {
    type Output = Quantity<u8, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for u16 {
    type Output = Quantity<u16, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for u32 {
    type Output = Quantity<u32, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for u64 {
    type Output = Quantity<u64, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for u128 {
    type Output = Quantity<u128, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for usize {
    type Output = Quantity<usize, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for f32 {
    type Output = Quantity<f32, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
impl Mul<UnitQuectobaryesMul> for f64 {
    type Output = Quantity<f64, UnitQuectobaryes>;
    fn mul(self, _: UnitQuectobaryesMul) -> Self::Output {
        Quantity::new(self, UnitQuectobaryes)
    }
}
pub type Baryes<T> = Quantity<T, UnitBaryes>;
#[allow(non_upper_case_globals)]
pub static Baryes: UnitBaryesMul = UnitBaryesMul;
pub type Quettabaryes<T> = Quantity<T, UnitQuettabaryes>;
#[allow(non_upper_case_globals)]
pub static Quettabaryes: UnitQuettabaryesMul = UnitQuettabaryesMul;
pub type Ronnabaryes<T> = Quantity<T, UnitRonnabaryes>;
#[allow(non_upper_case_globals)]
pub static Ronnabaryes: UnitRonnabaryesMul = UnitRonnabaryesMul;
pub type Yottabaryes<T> = Quantity<T, UnitYottabaryes>;
#[allow(non_upper_case_globals)]
pub static Yottabaryes: UnitYottabaryesMul = UnitYottabaryesMul;
pub type Zettabaryes<T> = Quantity<T, UnitZettabaryes>;
#[allow(non_upper_case_globals)]
pub static Zettabaryes: UnitZettabaryesMul = UnitZettabaryesMul;
pub type Exabaryes<T> = Quantity<T, UnitExabaryes>;
#[allow(non_upper_case_globals)]
pub static Exabaryes: UnitExabaryesMul = UnitExabaryesMul;
pub type Petabaryes<T> = Quantity<T, UnitPetabaryes>;
#[allow(non_upper_case_globals)]
pub static Petabaryes: UnitPetabaryesMul = UnitPetabaryesMul;
pub type Terabaryes<T> = Quantity<T, UnitTerabaryes>;
#[allow(non_upper_case_globals)]
pub static Terabaryes: UnitTerabaryesMul = UnitTerabaryesMul;
pub type Gigabaryes<T> = Quantity<T, UnitGigabaryes>;
#[allow(non_upper_case_globals)]
pub static Gigabaryes: UnitGigabaryesMul = UnitGigabaryesMul;
pub type Megabaryes<T> = Quantity<T, UnitMegabaryes>;
#[allow(non_upper_case_globals)]
pub static Megabaryes: UnitMegabaryesMul = UnitMegabaryesMul;
pub type Kilobaryes<T> = Quantity<T, UnitKilobaryes>;
#[allow(non_upper_case_globals)]
pub static Kilobaryes: UnitKilobaryesMul = UnitKilobaryesMul;
pub type Hectobaryes<T> = Quantity<T, UnitHectobaryes>;
#[allow(non_upper_case_globals)]
pub static Hectobaryes: UnitHectobaryesMul = UnitHectobaryesMul;
pub type Decabaryes<T> = Quantity<T, UnitDecabaryes>;
#[allow(non_upper_case_globals)]
pub static Decabaryes: UnitDecabaryesMul = UnitDecabaryesMul;
pub type Decibaryes<T> = Quantity<T, UnitDecibaryes>;
#[allow(non_upper_case_globals)]
pub static Decibaryes: UnitDecibaryesMul = UnitDecibaryesMul;
pub type Centibaryes<T> = Quantity<T, UnitCentibaryes>;
#[allow(non_upper_case_globals)]
pub static Centibaryes: UnitCentibaryesMul = UnitCentibaryesMul;
pub type Millibaryes<T> = Quantity<T, UnitMillibaryes>;
#[allow(non_upper_case_globals)]
pub static Millibaryes: UnitMillibaryesMul = UnitMillibaryesMul;
pub type Microbaryes<T> = Quantity<T, UnitMicrobaryes>;
#[allow(non_upper_case_globals)]
pub static Microbaryes: UnitMicrobaryesMul = UnitMicrobaryesMul;
pub type Nanobaryes<T> = Quantity<T, UnitNanobaryes>;
#[allow(non_upper_case_globals)]
pub static Nanobaryes: UnitNanobaryesMul = UnitNanobaryesMul;
pub type Picobaryes<T> = Quantity<T, UnitPicobaryes>;
#[allow(non_upper_case_globals)]
pub static Picobaryes: UnitPicobaryesMul = UnitPicobaryesMul;
pub type Femtobaryes<T> = Quantity<T, UnitFemtobaryes>;
#[allow(non_upper_case_globals)]
pub static Femtobaryes: UnitFemtobaryesMul = UnitFemtobaryesMul;
pub type Attobaryes<T> = Quantity<T, UnitAttobaryes>;
#[allow(non_upper_case_globals)]
pub static Attobaryes: UnitAttobaryesMul = UnitAttobaryesMul;
pub type Zeptobaryes<T> = Quantity<T, UnitZeptobaryes>;
#[allow(non_upper_case_globals)]
pub static Zeptobaryes: UnitZeptobaryesMul = UnitZeptobaryesMul;
pub type Yoctobaryes<T> = Quantity<T, UnitYoctobaryes>;
#[allow(non_upper_case_globals)]
pub static Yoctobaryes: UnitYoctobaryesMul = UnitYoctobaryesMul;
pub type Rontobaryes<T> = Quantity<T, UnitRontobaryes>;
#[allow(non_upper_case_globals)]
pub static Rontobaryes: UnitRontobaryesMul = UnitRontobaryesMul;
pub type Quectobaryes<T> = Quantity<T, UnitQuectobaryes>;
#[allow(non_upper_case_globals)]
pub static Quectobaryes: UnitQuectobaryesMul = UnitQuectobaryesMul;
pub struct UnitErgs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitErgs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitErgs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitErgs {
    #[inline]
    fn clone(&self) -> UnitErgs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitErgs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitErgs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitErgs {
    #[inline]
    fn eq(&self, other: &UnitErgs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitErgs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitErgs {
    fn default() -> Self {
        UnitErgs
    }
}
impl Add<UnitErgs> for UnitErgs {
    type Output = UnitErgs;
    #[inline]
    fn add(self, _: UnitErgs) -> Self::Output {
        UnitErgs
    }
}
impl AddAssign<UnitErgs> for UnitErgs {
    #[inline]
    fn add_assign(&mut self, _: UnitErgs) {}
}
impl Sub<UnitErgs> for UnitErgs {
    type Output = UnitErgs;
    #[inline]
    fn sub(self, _: UnitErgs) -> Self::Output {
        UnitErgs
    }
}
impl SubAssign<UnitErgs> for UnitErgs {
    #[inline]
    fn sub_assign(&mut self, _: UnitErgs) {}
}
pub struct UnitErgsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitErgsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitErgsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitErgsMul {
    #[inline]
    fn clone(&self) -> UnitErgsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitErgsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitErgsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitErgsMul {
    #[inline]
    fn eq(&self, other: &UnitErgsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitErgsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitErgsMul> for i8 {
    type Output = Quantity<i8, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for i16 {
    type Output = Quantity<i16, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for i32 {
    type Output = Quantity<i32, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for i64 {
    type Output = Quantity<i64, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for i128 {
    type Output = Quantity<i128, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for isize {
    type Output = Quantity<isize, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for u8 {
    type Output = Quantity<u8, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for u16 {
    type Output = Quantity<u16, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for u32 {
    type Output = Quantity<u32, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for u64 {
    type Output = Quantity<u64, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for u128 {
    type Output = Quantity<u128, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for usize {
    type Output = Quantity<usize, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for f32 {
    type Output = Quantity<f32, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
impl Mul<UnitErgsMul> for f64 {
    type Output = Quantity<f64, UnitErgs>;
    fn mul(self, _: UnitErgsMul) -> Self::Output {
        Quantity::new(self, UnitErgs)
    }
}
pub struct UnitQuettaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaergs {
    #[inline]
    fn clone(&self) -> UnitQuettaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaergs {
    #[inline]
    fn eq(&self, other: &UnitQuettaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaergs {
    fn default() -> Self {
        UnitQuettaergs
    }
}
impl Add<UnitQuettaergs> for UnitQuettaergs {
    type Output = UnitQuettaergs;
    #[inline]
    fn add(self, _: UnitQuettaergs) -> Self::Output {
        UnitQuettaergs
    }
}
impl AddAssign<UnitQuettaergs> for UnitQuettaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaergs) {}
}
impl Sub<UnitQuettaergs> for UnitQuettaergs {
    type Output = UnitQuettaergs;
    #[inline]
    fn sub(self, _: UnitQuettaergs) -> Self::Output {
        UnitQuettaergs
    }
}
impl SubAssign<UnitQuettaergs> for UnitQuettaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaergs) {}
}
pub struct UnitQuettaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaergsMul {
    #[inline]
    fn clone(&self) -> UnitQuettaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaergsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaergsMul> for i8 {
    type Output = Quantity<i8, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for i16 {
    type Output = Quantity<i16, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for i32 {
    type Output = Quantity<i32, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for i64 {
    type Output = Quantity<i64, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for i128 {
    type Output = Quantity<i128, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for isize {
    type Output = Quantity<isize, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for u8 {
    type Output = Quantity<u8, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for u16 {
    type Output = Quantity<u16, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for u32 {
    type Output = Quantity<u32, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for u64 {
    type Output = Quantity<u64, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for u128 {
    type Output = Quantity<u128, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for usize {
    type Output = Quantity<usize, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for f32 {
    type Output = Quantity<f32, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
impl Mul<UnitQuettaergsMul> for f64 {
    type Output = Quantity<f64, UnitQuettaergs>;
    fn mul(self, _: UnitQuettaergsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaergs)
    }
}
pub struct UnitRonnaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaergs {
    #[inline]
    fn clone(&self) -> UnitRonnaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaergs {
    #[inline]
    fn eq(&self, other: &UnitRonnaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaergs {
    fn default() -> Self {
        UnitRonnaergs
    }
}
impl Add<UnitRonnaergs> for UnitRonnaergs {
    type Output = UnitRonnaergs;
    #[inline]
    fn add(self, _: UnitRonnaergs) -> Self::Output {
        UnitRonnaergs
    }
}
impl AddAssign<UnitRonnaergs> for UnitRonnaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaergs) {}
}
impl Sub<UnitRonnaergs> for UnitRonnaergs {
    type Output = UnitRonnaergs;
    #[inline]
    fn sub(self, _: UnitRonnaergs) -> Self::Output {
        UnitRonnaergs
    }
}
impl SubAssign<UnitRonnaergs> for UnitRonnaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaergs) {}
}
pub struct UnitRonnaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaergsMul {
    #[inline]
    fn clone(&self) -> UnitRonnaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaergsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaergsMul> for i8 {
    type Output = Quantity<i8, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for i16 {
    type Output = Quantity<i16, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for i32 {
    type Output = Quantity<i32, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for i64 {
    type Output = Quantity<i64, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for i128 {
    type Output = Quantity<i128, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for isize {
    type Output = Quantity<isize, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for u8 {
    type Output = Quantity<u8, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for u16 {
    type Output = Quantity<u16, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for u32 {
    type Output = Quantity<u32, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for u64 {
    type Output = Quantity<u64, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for u128 {
    type Output = Quantity<u128, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for usize {
    type Output = Quantity<usize, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for f32 {
    type Output = Quantity<f32, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
impl Mul<UnitRonnaergsMul> for f64 {
    type Output = Quantity<f64, UnitRonnaergs>;
    fn mul(self, _: UnitRonnaergsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaergs)
    }
}
pub struct UnitYottaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaergs {
    #[inline]
    fn clone(&self) -> UnitYottaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaergs {
    #[inline]
    fn eq(&self, other: &UnitYottaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaergs {
    fn default() -> Self {
        UnitYottaergs
    }
}
impl Add<UnitYottaergs> for UnitYottaergs {
    type Output = UnitYottaergs;
    #[inline]
    fn add(self, _: UnitYottaergs) -> Self::Output {
        UnitYottaergs
    }
}
impl AddAssign<UnitYottaergs> for UnitYottaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaergs) {}
}
impl Sub<UnitYottaergs> for UnitYottaergs {
    type Output = UnitYottaergs;
    #[inline]
    fn sub(self, _: UnitYottaergs) -> Self::Output {
        UnitYottaergs
    }
}
impl SubAssign<UnitYottaergs> for UnitYottaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaergs) {}
}
pub struct UnitYottaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaergsMul {
    #[inline]
    fn clone(&self) -> UnitYottaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaergsMul {
    #[inline]
    fn eq(&self, other: &UnitYottaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaergsMul> for i8 {
    type Output = Quantity<i8, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for i16 {
    type Output = Quantity<i16, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for i32 {
    type Output = Quantity<i32, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for i64 {
    type Output = Quantity<i64, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for i128 {
    type Output = Quantity<i128, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for isize {
    type Output = Quantity<isize, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for u8 {
    type Output = Quantity<u8, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for u16 {
    type Output = Quantity<u16, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for u32 {
    type Output = Quantity<u32, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for u64 {
    type Output = Quantity<u64, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for u128 {
    type Output = Quantity<u128, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for usize {
    type Output = Quantity<usize, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for f32 {
    type Output = Quantity<f32, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
impl Mul<UnitYottaergsMul> for f64 {
    type Output = Quantity<f64, UnitYottaergs>;
    fn mul(self, _: UnitYottaergsMul) -> Self::Output {
        Quantity::new(self, UnitYottaergs)
    }
}
pub struct UnitZettaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaergs {
    #[inline]
    fn clone(&self) -> UnitZettaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaergs {
    #[inline]
    fn eq(&self, other: &UnitZettaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaergs {
    fn default() -> Self {
        UnitZettaergs
    }
}
impl Add<UnitZettaergs> for UnitZettaergs {
    type Output = UnitZettaergs;
    #[inline]
    fn add(self, _: UnitZettaergs) -> Self::Output {
        UnitZettaergs
    }
}
impl AddAssign<UnitZettaergs> for UnitZettaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaergs) {}
}
impl Sub<UnitZettaergs> for UnitZettaergs {
    type Output = UnitZettaergs;
    #[inline]
    fn sub(self, _: UnitZettaergs) -> Self::Output {
        UnitZettaergs
    }
}
impl SubAssign<UnitZettaergs> for UnitZettaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaergs) {}
}
pub struct UnitZettaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaergsMul {
    #[inline]
    fn clone(&self) -> UnitZettaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaergsMul {
    #[inline]
    fn eq(&self, other: &UnitZettaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaergsMul> for i8 {
    type Output = Quantity<i8, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for i16 {
    type Output = Quantity<i16, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for i32 {
    type Output = Quantity<i32, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for i64 {
    type Output = Quantity<i64, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for i128 {
    type Output = Quantity<i128, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for isize {
    type Output = Quantity<isize, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for u8 {
    type Output = Quantity<u8, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for u16 {
    type Output = Quantity<u16, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for u32 {
    type Output = Quantity<u32, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for u64 {
    type Output = Quantity<u64, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for u128 {
    type Output = Quantity<u128, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for usize {
    type Output = Quantity<usize, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for f32 {
    type Output = Quantity<f32, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
impl Mul<UnitZettaergsMul> for f64 {
    type Output = Quantity<f64, UnitZettaergs>;
    fn mul(self, _: UnitZettaergsMul) -> Self::Output {
        Quantity::new(self, UnitZettaergs)
    }
}
pub struct UnitExaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaergs {
    #[inline]
    fn clone(&self) -> UnitExaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaergs {
    #[inline]
    fn eq(&self, other: &UnitExaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaergs {
    fn default() -> Self {
        UnitExaergs
    }
}
impl Add<UnitExaergs> for UnitExaergs {
    type Output = UnitExaergs;
    #[inline]
    fn add(self, _: UnitExaergs) -> Self::Output {
        UnitExaergs
    }
}
impl AddAssign<UnitExaergs> for UnitExaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitExaergs) {}
}
impl Sub<UnitExaergs> for UnitExaergs {
    type Output = UnitExaergs;
    #[inline]
    fn sub(self, _: UnitExaergs) -> Self::Output {
        UnitExaergs
    }
}
impl SubAssign<UnitExaergs> for UnitExaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaergs) {}
}
pub struct UnitExaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaergsMul {
    #[inline]
    fn clone(&self) -> UnitExaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaergsMul {
    #[inline]
    fn eq(&self, other: &UnitExaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaergsMul> for i8 {
    type Output = Quantity<i8, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for i16 {
    type Output = Quantity<i16, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for i32 {
    type Output = Quantity<i32, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for i64 {
    type Output = Quantity<i64, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for i128 {
    type Output = Quantity<i128, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for isize {
    type Output = Quantity<isize, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for u8 {
    type Output = Quantity<u8, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for u16 {
    type Output = Quantity<u16, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for u32 {
    type Output = Quantity<u32, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for u64 {
    type Output = Quantity<u64, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for u128 {
    type Output = Quantity<u128, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for usize {
    type Output = Quantity<usize, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for f32 {
    type Output = Quantity<f32, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
impl Mul<UnitExaergsMul> for f64 {
    type Output = Quantity<f64, UnitExaergs>;
    fn mul(self, _: UnitExaergsMul) -> Self::Output {
        Quantity::new(self, UnitExaergs)
    }
}
pub struct UnitPetaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaergs {
    #[inline]
    fn clone(&self) -> UnitPetaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaergs {
    #[inline]
    fn eq(&self, other: &UnitPetaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaergs {
    fn default() -> Self {
        UnitPetaergs
    }
}
impl Add<UnitPetaergs> for UnitPetaergs {
    type Output = UnitPetaergs;
    #[inline]
    fn add(self, _: UnitPetaergs) -> Self::Output {
        UnitPetaergs
    }
}
impl AddAssign<UnitPetaergs> for UnitPetaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaergs) {}
}
impl Sub<UnitPetaergs> for UnitPetaergs {
    type Output = UnitPetaergs;
    #[inline]
    fn sub(self, _: UnitPetaergs) -> Self::Output {
        UnitPetaergs
    }
}
impl SubAssign<UnitPetaergs> for UnitPetaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaergs) {}
}
pub struct UnitPetaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaergsMul {
    #[inline]
    fn clone(&self) -> UnitPetaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaergsMul {
    #[inline]
    fn eq(&self, other: &UnitPetaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaergsMul> for i8 {
    type Output = Quantity<i8, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for i16 {
    type Output = Quantity<i16, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for i32 {
    type Output = Quantity<i32, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for i64 {
    type Output = Quantity<i64, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for i128 {
    type Output = Quantity<i128, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for isize {
    type Output = Quantity<isize, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for u8 {
    type Output = Quantity<u8, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for u16 {
    type Output = Quantity<u16, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for u32 {
    type Output = Quantity<u32, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for u64 {
    type Output = Quantity<u64, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for u128 {
    type Output = Quantity<u128, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for usize {
    type Output = Quantity<usize, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for f32 {
    type Output = Quantity<f32, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
impl Mul<UnitPetaergsMul> for f64 {
    type Output = Quantity<f64, UnitPetaergs>;
    fn mul(self, _: UnitPetaergsMul) -> Self::Output {
        Quantity::new(self, UnitPetaergs)
    }
}
pub struct UnitTeraergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraergs {
    #[inline]
    fn clone(&self) -> UnitTeraergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraergs {
    #[inline]
    fn eq(&self, other: &UnitTeraergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraergs {
    fn default() -> Self {
        UnitTeraergs
    }
}
impl Add<UnitTeraergs> for UnitTeraergs {
    type Output = UnitTeraergs;
    #[inline]
    fn add(self, _: UnitTeraergs) -> Self::Output {
        UnitTeraergs
    }
}
impl AddAssign<UnitTeraergs> for UnitTeraergs {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraergs) {}
}
impl Sub<UnitTeraergs> for UnitTeraergs {
    type Output = UnitTeraergs;
    #[inline]
    fn sub(self, _: UnitTeraergs) -> Self::Output {
        UnitTeraergs
    }
}
impl SubAssign<UnitTeraergs> for UnitTeraergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraergs) {}
}
pub struct UnitTeraergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraergsMul {
    #[inline]
    fn clone(&self) -> UnitTeraergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraergsMul {
    #[inline]
    fn eq(&self, other: &UnitTeraergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraergsMul> for i8 {
    type Output = Quantity<i8, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for i16 {
    type Output = Quantity<i16, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for i32 {
    type Output = Quantity<i32, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for i64 {
    type Output = Quantity<i64, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for i128 {
    type Output = Quantity<i128, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for isize {
    type Output = Quantity<isize, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for u8 {
    type Output = Quantity<u8, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for u16 {
    type Output = Quantity<u16, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for u32 {
    type Output = Quantity<u32, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for u64 {
    type Output = Quantity<u64, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for u128 {
    type Output = Quantity<u128, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for usize {
    type Output = Quantity<usize, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for f32 {
    type Output = Quantity<f32, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
impl Mul<UnitTeraergsMul> for f64 {
    type Output = Quantity<f64, UnitTeraergs>;
    fn mul(self, _: UnitTeraergsMul) -> Self::Output {
        Quantity::new(self, UnitTeraergs)
    }
}
pub struct UnitGigaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaergs {
    #[inline]
    fn clone(&self) -> UnitGigaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaergs {
    #[inline]
    fn eq(&self, other: &UnitGigaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaergs {
    fn default() -> Self {
        UnitGigaergs
    }
}
impl Add<UnitGigaergs> for UnitGigaergs {
    type Output = UnitGigaergs;
    #[inline]
    fn add(self, _: UnitGigaergs) -> Self::Output {
        UnitGigaergs
    }
}
impl AddAssign<UnitGigaergs> for UnitGigaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaergs) {}
}
impl Sub<UnitGigaergs> for UnitGigaergs {
    type Output = UnitGigaergs;
    #[inline]
    fn sub(self, _: UnitGigaergs) -> Self::Output {
        UnitGigaergs
    }
}
impl SubAssign<UnitGigaergs> for UnitGigaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaergs) {}
}
pub struct UnitGigaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaergsMul {
    #[inline]
    fn clone(&self) -> UnitGigaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaergsMul {
    #[inline]
    fn eq(&self, other: &UnitGigaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaergsMul> for i8 {
    type Output = Quantity<i8, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for i16 {
    type Output = Quantity<i16, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for i32 {
    type Output = Quantity<i32, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for i64 {
    type Output = Quantity<i64, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for i128 {
    type Output = Quantity<i128, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for isize {
    type Output = Quantity<isize, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for u8 {
    type Output = Quantity<u8, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for u16 {
    type Output = Quantity<u16, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for u32 {
    type Output = Quantity<u32, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for u64 {
    type Output = Quantity<u64, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for u128 {
    type Output = Quantity<u128, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for usize {
    type Output = Quantity<usize, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for f32 {
    type Output = Quantity<f32, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
impl Mul<UnitGigaergsMul> for f64 {
    type Output = Quantity<f64, UnitGigaergs>;
    fn mul(self, _: UnitGigaergsMul) -> Self::Output {
        Quantity::new(self, UnitGigaergs)
    }
}
pub struct UnitMegaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaergs {
    #[inline]
    fn clone(&self) -> UnitMegaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaergs {
    #[inline]
    fn eq(&self, other: &UnitMegaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaergs {
    fn default() -> Self {
        UnitMegaergs
    }
}
impl Add<UnitMegaergs> for UnitMegaergs {
    type Output = UnitMegaergs;
    #[inline]
    fn add(self, _: UnitMegaergs) -> Self::Output {
        UnitMegaergs
    }
}
impl AddAssign<UnitMegaergs> for UnitMegaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaergs) {}
}
impl Sub<UnitMegaergs> for UnitMegaergs {
    type Output = UnitMegaergs;
    #[inline]
    fn sub(self, _: UnitMegaergs) -> Self::Output {
        UnitMegaergs
    }
}
impl SubAssign<UnitMegaergs> for UnitMegaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaergs) {}
}
pub struct UnitMegaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaergsMul {
    #[inline]
    fn clone(&self) -> UnitMegaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaergsMul {
    #[inline]
    fn eq(&self, other: &UnitMegaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaergsMul> for i8 {
    type Output = Quantity<i8, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for i16 {
    type Output = Quantity<i16, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for i32 {
    type Output = Quantity<i32, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for i64 {
    type Output = Quantity<i64, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for i128 {
    type Output = Quantity<i128, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for isize {
    type Output = Quantity<isize, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for u8 {
    type Output = Quantity<u8, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for u16 {
    type Output = Quantity<u16, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for u32 {
    type Output = Quantity<u32, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for u64 {
    type Output = Quantity<u64, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for u128 {
    type Output = Quantity<u128, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for usize {
    type Output = Quantity<usize, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for f32 {
    type Output = Quantity<f32, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
impl Mul<UnitMegaergsMul> for f64 {
    type Output = Quantity<f64, UnitMegaergs>;
    fn mul(self, _: UnitMegaergsMul) -> Self::Output {
        Quantity::new(self, UnitMegaergs)
    }
}
pub struct UnitKiloergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloergs {
    #[inline]
    fn clone(&self) -> UnitKiloergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloergs {
    #[inline]
    fn eq(&self, other: &UnitKiloergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloergs {
    fn default() -> Self {
        UnitKiloergs
    }
}
impl Add<UnitKiloergs> for UnitKiloergs {
    type Output = UnitKiloergs;
    #[inline]
    fn add(self, _: UnitKiloergs) -> Self::Output {
        UnitKiloergs
    }
}
impl AddAssign<UnitKiloergs> for UnitKiloergs {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloergs) {}
}
impl Sub<UnitKiloergs> for UnitKiloergs {
    type Output = UnitKiloergs;
    #[inline]
    fn sub(self, _: UnitKiloergs) -> Self::Output {
        UnitKiloergs
    }
}
impl SubAssign<UnitKiloergs> for UnitKiloergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloergs) {}
}
pub struct UnitKiloergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloergsMul {
    #[inline]
    fn clone(&self) -> UnitKiloergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloergsMul {
    #[inline]
    fn eq(&self, other: &UnitKiloergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloergsMul> for i8 {
    type Output = Quantity<i8, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for i16 {
    type Output = Quantity<i16, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for i32 {
    type Output = Quantity<i32, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for i64 {
    type Output = Quantity<i64, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for i128 {
    type Output = Quantity<i128, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for isize {
    type Output = Quantity<isize, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for u8 {
    type Output = Quantity<u8, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for u16 {
    type Output = Quantity<u16, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for u32 {
    type Output = Quantity<u32, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for u64 {
    type Output = Quantity<u64, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for u128 {
    type Output = Quantity<u128, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for usize {
    type Output = Quantity<usize, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for f32 {
    type Output = Quantity<f32, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
impl Mul<UnitKiloergsMul> for f64 {
    type Output = Quantity<f64, UnitKiloergs>;
    fn mul(self, _: UnitKiloergsMul) -> Self::Output {
        Quantity::new(self, UnitKiloergs)
    }
}
pub struct UnitHectoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoergs {
    #[inline]
    fn clone(&self) -> UnitHectoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoergs {
    #[inline]
    fn eq(&self, other: &UnitHectoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoergs {
    fn default() -> Self {
        UnitHectoergs
    }
}
impl Add<UnitHectoergs> for UnitHectoergs {
    type Output = UnitHectoergs;
    #[inline]
    fn add(self, _: UnitHectoergs) -> Self::Output {
        UnitHectoergs
    }
}
impl AddAssign<UnitHectoergs> for UnitHectoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoergs) {}
}
impl Sub<UnitHectoergs> for UnitHectoergs {
    type Output = UnitHectoergs;
    #[inline]
    fn sub(self, _: UnitHectoergs) -> Self::Output {
        UnitHectoergs
    }
}
impl SubAssign<UnitHectoergs> for UnitHectoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoergs) {}
}
pub struct UnitHectoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoergsMul {
    #[inline]
    fn clone(&self) -> UnitHectoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoergsMul {
    #[inline]
    fn eq(&self, other: &UnitHectoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoergsMul> for i8 {
    type Output = Quantity<i8, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for i16 {
    type Output = Quantity<i16, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for i32 {
    type Output = Quantity<i32, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for i64 {
    type Output = Quantity<i64, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for i128 {
    type Output = Quantity<i128, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for isize {
    type Output = Quantity<isize, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for u8 {
    type Output = Quantity<u8, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for u16 {
    type Output = Quantity<u16, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for u32 {
    type Output = Quantity<u32, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for u64 {
    type Output = Quantity<u64, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for u128 {
    type Output = Quantity<u128, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for usize {
    type Output = Quantity<usize, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for f32 {
    type Output = Quantity<f32, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
impl Mul<UnitHectoergsMul> for f64 {
    type Output = Quantity<f64, UnitHectoergs>;
    fn mul(self, _: UnitHectoergsMul) -> Self::Output {
        Quantity::new(self, UnitHectoergs)
    }
}
pub struct UnitDecaergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaergs {
    #[inline]
    fn clone(&self) -> UnitDecaergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaergs {
    #[inline]
    fn eq(&self, other: &UnitDecaergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaergs {
    fn default() -> Self {
        UnitDecaergs
    }
}
impl Add<UnitDecaergs> for UnitDecaergs {
    type Output = UnitDecaergs;
    #[inline]
    fn add(self, _: UnitDecaergs) -> Self::Output {
        UnitDecaergs
    }
}
impl AddAssign<UnitDecaergs> for UnitDecaergs {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaergs) {}
}
impl Sub<UnitDecaergs> for UnitDecaergs {
    type Output = UnitDecaergs;
    #[inline]
    fn sub(self, _: UnitDecaergs) -> Self::Output {
        UnitDecaergs
    }
}
impl SubAssign<UnitDecaergs> for UnitDecaergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaergs) {}
}
pub struct UnitDecaergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaergsMul {
    #[inline]
    fn clone(&self) -> UnitDecaergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaergsMul {
    #[inline]
    fn eq(&self, other: &UnitDecaergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaergsMul> for i8 {
    type Output = Quantity<i8, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for i16 {
    type Output = Quantity<i16, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for i32 {
    type Output = Quantity<i32, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for i64 {
    type Output = Quantity<i64, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for i128 {
    type Output = Quantity<i128, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for isize {
    type Output = Quantity<isize, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for u8 {
    type Output = Quantity<u8, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for u16 {
    type Output = Quantity<u16, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for u32 {
    type Output = Quantity<u32, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for u64 {
    type Output = Quantity<u64, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for u128 {
    type Output = Quantity<u128, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for usize {
    type Output = Quantity<usize, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for f32 {
    type Output = Quantity<f32, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
impl Mul<UnitDecaergsMul> for f64 {
    type Output = Quantity<f64, UnitDecaergs>;
    fn mul(self, _: UnitDecaergsMul) -> Self::Output {
        Quantity::new(self, UnitDecaergs)
    }
}
pub struct UnitDeciergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciergs {
    #[inline]
    fn clone(&self) -> UnitDeciergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciergs {
    #[inline]
    fn eq(&self, other: &UnitDeciergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciergs {
    fn default() -> Self {
        UnitDeciergs
    }
}
impl Add<UnitDeciergs> for UnitDeciergs {
    type Output = UnitDeciergs;
    #[inline]
    fn add(self, _: UnitDeciergs) -> Self::Output {
        UnitDeciergs
    }
}
impl AddAssign<UnitDeciergs> for UnitDeciergs {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciergs) {}
}
impl Sub<UnitDeciergs> for UnitDeciergs {
    type Output = UnitDeciergs;
    #[inline]
    fn sub(self, _: UnitDeciergs) -> Self::Output {
        UnitDeciergs
    }
}
impl SubAssign<UnitDeciergs> for UnitDeciergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciergs) {}
}
pub struct UnitDeciergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciergsMul {
    #[inline]
    fn clone(&self) -> UnitDeciergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciergsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciergsMul> for i8 {
    type Output = Quantity<i8, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for i16 {
    type Output = Quantity<i16, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for i32 {
    type Output = Quantity<i32, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for i64 {
    type Output = Quantity<i64, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for i128 {
    type Output = Quantity<i128, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for isize {
    type Output = Quantity<isize, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for u8 {
    type Output = Quantity<u8, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for u16 {
    type Output = Quantity<u16, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for u32 {
    type Output = Quantity<u32, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for u64 {
    type Output = Quantity<u64, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for u128 {
    type Output = Quantity<u128, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for usize {
    type Output = Quantity<usize, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for f32 {
    type Output = Quantity<f32, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
impl Mul<UnitDeciergsMul> for f64 {
    type Output = Quantity<f64, UnitDeciergs>;
    fn mul(self, _: UnitDeciergsMul) -> Self::Output {
        Quantity::new(self, UnitDeciergs)
    }
}
pub struct UnitCentiergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiergs {
    #[inline]
    fn clone(&self) -> UnitCentiergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiergs {
    #[inline]
    fn eq(&self, other: &UnitCentiergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiergs {
    fn default() -> Self {
        UnitCentiergs
    }
}
impl Add<UnitCentiergs> for UnitCentiergs {
    type Output = UnitCentiergs;
    #[inline]
    fn add(self, _: UnitCentiergs) -> Self::Output {
        UnitCentiergs
    }
}
impl AddAssign<UnitCentiergs> for UnitCentiergs {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiergs) {}
}
impl Sub<UnitCentiergs> for UnitCentiergs {
    type Output = UnitCentiergs;
    #[inline]
    fn sub(self, _: UnitCentiergs) -> Self::Output {
        UnitCentiergs
    }
}
impl SubAssign<UnitCentiergs> for UnitCentiergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiergs) {}
}
pub struct UnitCentiergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiergsMul {
    #[inline]
    fn clone(&self) -> UnitCentiergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiergsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiergsMul> for i8 {
    type Output = Quantity<i8, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for i16 {
    type Output = Quantity<i16, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for i32 {
    type Output = Quantity<i32, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for i64 {
    type Output = Quantity<i64, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for i128 {
    type Output = Quantity<i128, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for isize {
    type Output = Quantity<isize, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for u8 {
    type Output = Quantity<u8, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for u16 {
    type Output = Quantity<u16, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for u32 {
    type Output = Quantity<u32, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for u64 {
    type Output = Quantity<u64, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for u128 {
    type Output = Quantity<u128, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for usize {
    type Output = Quantity<usize, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for f32 {
    type Output = Quantity<f32, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
impl Mul<UnitCentiergsMul> for f64 {
    type Output = Quantity<f64, UnitCentiergs>;
    fn mul(self, _: UnitCentiergsMul) -> Self::Output {
        Quantity::new(self, UnitCentiergs)
    }
}
pub struct UnitMilliergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliergs {
    #[inline]
    fn clone(&self) -> UnitMilliergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliergs {
    #[inline]
    fn eq(&self, other: &UnitMilliergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliergs {
    fn default() -> Self {
        UnitMilliergs
    }
}
impl Add<UnitMilliergs> for UnitMilliergs {
    type Output = UnitMilliergs;
    #[inline]
    fn add(self, _: UnitMilliergs) -> Self::Output {
        UnitMilliergs
    }
}
impl AddAssign<UnitMilliergs> for UnitMilliergs {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliergs) {}
}
impl Sub<UnitMilliergs> for UnitMilliergs {
    type Output = UnitMilliergs;
    #[inline]
    fn sub(self, _: UnitMilliergs) -> Self::Output {
        UnitMilliergs
    }
}
impl SubAssign<UnitMilliergs> for UnitMilliergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliergs) {}
}
pub struct UnitMilliergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliergsMul {
    #[inline]
    fn clone(&self) -> UnitMilliergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliergsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliergsMul> for i8 {
    type Output = Quantity<i8, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for i16 {
    type Output = Quantity<i16, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for i32 {
    type Output = Quantity<i32, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for i64 {
    type Output = Quantity<i64, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for i128 {
    type Output = Quantity<i128, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for isize {
    type Output = Quantity<isize, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for u8 {
    type Output = Quantity<u8, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for u16 {
    type Output = Quantity<u16, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for u32 {
    type Output = Quantity<u32, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for u64 {
    type Output = Quantity<u64, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for u128 {
    type Output = Quantity<u128, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for usize {
    type Output = Quantity<usize, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for f32 {
    type Output = Quantity<f32, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
impl Mul<UnitMilliergsMul> for f64 {
    type Output = Quantity<f64, UnitMilliergs>;
    fn mul(self, _: UnitMilliergsMul) -> Self::Output {
        Quantity::new(self, UnitMilliergs)
    }
}
pub struct UnitMicroergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroergs {
    #[inline]
    fn clone(&self) -> UnitMicroergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroergs {
    #[inline]
    fn eq(&self, other: &UnitMicroergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroergs {
    fn default() -> Self {
        UnitMicroergs
    }
}
impl Add<UnitMicroergs> for UnitMicroergs {
    type Output = UnitMicroergs;
    #[inline]
    fn add(self, _: UnitMicroergs) -> Self::Output {
        UnitMicroergs
    }
}
impl AddAssign<UnitMicroergs> for UnitMicroergs {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroergs) {}
}
impl Sub<UnitMicroergs> for UnitMicroergs {
    type Output = UnitMicroergs;
    #[inline]
    fn sub(self, _: UnitMicroergs) -> Self::Output {
        UnitMicroergs
    }
}
impl SubAssign<UnitMicroergs> for UnitMicroergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroergs) {}
}
pub struct UnitMicroergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroergsMul {
    #[inline]
    fn clone(&self) -> UnitMicroergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroergsMul {
    #[inline]
    fn eq(&self, other: &UnitMicroergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroergsMul> for i8 {
    type Output = Quantity<i8, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for i16 {
    type Output = Quantity<i16, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for i32 {
    type Output = Quantity<i32, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for i64 {
    type Output = Quantity<i64, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for i128 {
    type Output = Quantity<i128, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for isize {
    type Output = Quantity<isize, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for u8 {
    type Output = Quantity<u8, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for u16 {
    type Output = Quantity<u16, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for u32 {
    type Output = Quantity<u32, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for u64 {
    type Output = Quantity<u64, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for u128 {
    type Output = Quantity<u128, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for usize {
    type Output = Quantity<usize, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for f32 {
    type Output = Quantity<f32, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
impl Mul<UnitMicroergsMul> for f64 {
    type Output = Quantity<f64, UnitMicroergs>;
    fn mul(self, _: UnitMicroergsMul) -> Self::Output {
        Quantity::new(self, UnitMicroergs)
    }
}
pub struct UnitNanoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoergs {
    #[inline]
    fn clone(&self) -> UnitNanoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoergs {
    #[inline]
    fn eq(&self, other: &UnitNanoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoergs {
    fn default() -> Self {
        UnitNanoergs
    }
}
impl Add<UnitNanoergs> for UnitNanoergs {
    type Output = UnitNanoergs;
    #[inline]
    fn add(self, _: UnitNanoergs) -> Self::Output {
        UnitNanoergs
    }
}
impl AddAssign<UnitNanoergs> for UnitNanoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoergs) {}
}
impl Sub<UnitNanoergs> for UnitNanoergs {
    type Output = UnitNanoergs;
    #[inline]
    fn sub(self, _: UnitNanoergs) -> Self::Output {
        UnitNanoergs
    }
}
impl SubAssign<UnitNanoergs> for UnitNanoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoergs) {}
}
pub struct UnitNanoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoergsMul {
    #[inline]
    fn clone(&self) -> UnitNanoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoergsMul {
    #[inline]
    fn eq(&self, other: &UnitNanoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoergsMul> for i8 {
    type Output = Quantity<i8, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for i16 {
    type Output = Quantity<i16, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for i32 {
    type Output = Quantity<i32, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for i64 {
    type Output = Quantity<i64, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for i128 {
    type Output = Quantity<i128, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for isize {
    type Output = Quantity<isize, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for u8 {
    type Output = Quantity<u8, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for u16 {
    type Output = Quantity<u16, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for u32 {
    type Output = Quantity<u32, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for u64 {
    type Output = Quantity<u64, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for u128 {
    type Output = Quantity<u128, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for usize {
    type Output = Quantity<usize, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for f32 {
    type Output = Quantity<f32, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
impl Mul<UnitNanoergsMul> for f64 {
    type Output = Quantity<f64, UnitNanoergs>;
    fn mul(self, _: UnitNanoergsMul) -> Self::Output {
        Quantity::new(self, UnitNanoergs)
    }
}
pub struct UnitPicoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoergs {
    #[inline]
    fn clone(&self) -> UnitPicoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoergs {
    #[inline]
    fn eq(&self, other: &UnitPicoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoergs {
    fn default() -> Self {
        UnitPicoergs
    }
}
impl Add<UnitPicoergs> for UnitPicoergs {
    type Output = UnitPicoergs;
    #[inline]
    fn add(self, _: UnitPicoergs) -> Self::Output {
        UnitPicoergs
    }
}
impl AddAssign<UnitPicoergs> for UnitPicoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoergs) {}
}
impl Sub<UnitPicoergs> for UnitPicoergs {
    type Output = UnitPicoergs;
    #[inline]
    fn sub(self, _: UnitPicoergs) -> Self::Output {
        UnitPicoergs
    }
}
impl SubAssign<UnitPicoergs> for UnitPicoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoergs) {}
}
pub struct UnitPicoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoergsMul {
    #[inline]
    fn clone(&self) -> UnitPicoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoergsMul {
    #[inline]
    fn eq(&self, other: &UnitPicoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoergsMul> for i8 {
    type Output = Quantity<i8, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for i16 {
    type Output = Quantity<i16, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for i32 {
    type Output = Quantity<i32, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for i64 {
    type Output = Quantity<i64, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for i128 {
    type Output = Quantity<i128, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for isize {
    type Output = Quantity<isize, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for u8 {
    type Output = Quantity<u8, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for u16 {
    type Output = Quantity<u16, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for u32 {
    type Output = Quantity<u32, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for u64 {
    type Output = Quantity<u64, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for u128 {
    type Output = Quantity<u128, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for usize {
    type Output = Quantity<usize, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for f32 {
    type Output = Quantity<f32, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
impl Mul<UnitPicoergsMul> for f64 {
    type Output = Quantity<f64, UnitPicoergs>;
    fn mul(self, _: UnitPicoergsMul) -> Self::Output {
        Quantity::new(self, UnitPicoergs)
    }
}
pub struct UnitFemtoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoergs {
    #[inline]
    fn clone(&self) -> UnitFemtoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoergs {
    #[inline]
    fn eq(&self, other: &UnitFemtoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoergs {
    fn default() -> Self {
        UnitFemtoergs
    }
}
impl Add<UnitFemtoergs> for UnitFemtoergs {
    type Output = UnitFemtoergs;
    #[inline]
    fn add(self, _: UnitFemtoergs) -> Self::Output {
        UnitFemtoergs
    }
}
impl AddAssign<UnitFemtoergs> for UnitFemtoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoergs) {}
}
impl Sub<UnitFemtoergs> for UnitFemtoergs {
    type Output = UnitFemtoergs;
    #[inline]
    fn sub(self, _: UnitFemtoergs) -> Self::Output {
        UnitFemtoergs
    }
}
impl SubAssign<UnitFemtoergs> for UnitFemtoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoergs) {}
}
pub struct UnitFemtoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoergsMul {
    #[inline]
    fn clone(&self) -> UnitFemtoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoergsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoergsMul> for i8 {
    type Output = Quantity<i8, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for i16 {
    type Output = Quantity<i16, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for i32 {
    type Output = Quantity<i32, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for i64 {
    type Output = Quantity<i64, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for i128 {
    type Output = Quantity<i128, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for isize {
    type Output = Quantity<isize, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for u8 {
    type Output = Quantity<u8, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for u16 {
    type Output = Quantity<u16, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for u32 {
    type Output = Quantity<u32, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for u64 {
    type Output = Quantity<u64, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for u128 {
    type Output = Quantity<u128, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for usize {
    type Output = Quantity<usize, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for f32 {
    type Output = Quantity<f32, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
impl Mul<UnitFemtoergsMul> for f64 {
    type Output = Quantity<f64, UnitFemtoergs>;
    fn mul(self, _: UnitFemtoergsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoergs)
    }
}
pub struct UnitAttoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoergs {
    #[inline]
    fn clone(&self) -> UnitAttoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoergs {
    #[inline]
    fn eq(&self, other: &UnitAttoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoergs {
    fn default() -> Self {
        UnitAttoergs
    }
}
impl Add<UnitAttoergs> for UnitAttoergs {
    type Output = UnitAttoergs;
    #[inline]
    fn add(self, _: UnitAttoergs) -> Self::Output {
        UnitAttoergs
    }
}
impl AddAssign<UnitAttoergs> for UnitAttoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoergs) {}
}
impl Sub<UnitAttoergs> for UnitAttoergs {
    type Output = UnitAttoergs;
    #[inline]
    fn sub(self, _: UnitAttoergs) -> Self::Output {
        UnitAttoergs
    }
}
impl SubAssign<UnitAttoergs> for UnitAttoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoergs) {}
}
pub struct UnitAttoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoergsMul {
    #[inline]
    fn clone(&self) -> UnitAttoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoergsMul {
    #[inline]
    fn eq(&self, other: &UnitAttoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoergsMul> for i8 {
    type Output = Quantity<i8, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for i16 {
    type Output = Quantity<i16, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for i32 {
    type Output = Quantity<i32, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for i64 {
    type Output = Quantity<i64, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for i128 {
    type Output = Quantity<i128, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for isize {
    type Output = Quantity<isize, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for u8 {
    type Output = Quantity<u8, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for u16 {
    type Output = Quantity<u16, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for u32 {
    type Output = Quantity<u32, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for u64 {
    type Output = Quantity<u64, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for u128 {
    type Output = Quantity<u128, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for usize {
    type Output = Quantity<usize, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for f32 {
    type Output = Quantity<f32, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
impl Mul<UnitAttoergsMul> for f64 {
    type Output = Quantity<f64, UnitAttoergs>;
    fn mul(self, _: UnitAttoergsMul) -> Self::Output {
        Quantity::new(self, UnitAttoergs)
    }
}
pub struct UnitZeptoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoergs {
    #[inline]
    fn clone(&self) -> UnitZeptoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoergs {
    #[inline]
    fn eq(&self, other: &UnitZeptoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoergs {
    fn default() -> Self {
        UnitZeptoergs
    }
}
impl Add<UnitZeptoergs> for UnitZeptoergs {
    type Output = UnitZeptoergs;
    #[inline]
    fn add(self, _: UnitZeptoergs) -> Self::Output {
        UnitZeptoergs
    }
}
impl AddAssign<UnitZeptoergs> for UnitZeptoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoergs) {}
}
impl Sub<UnitZeptoergs> for UnitZeptoergs {
    type Output = UnitZeptoergs;
    #[inline]
    fn sub(self, _: UnitZeptoergs) -> Self::Output {
        UnitZeptoergs
    }
}
impl SubAssign<UnitZeptoergs> for UnitZeptoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoergs) {}
}
pub struct UnitZeptoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoergsMul {
    #[inline]
    fn clone(&self) -> UnitZeptoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoergsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoergsMul> for i8 {
    type Output = Quantity<i8, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for i16 {
    type Output = Quantity<i16, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for i32 {
    type Output = Quantity<i32, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for i64 {
    type Output = Quantity<i64, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for i128 {
    type Output = Quantity<i128, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for isize {
    type Output = Quantity<isize, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for u8 {
    type Output = Quantity<u8, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for u16 {
    type Output = Quantity<u16, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for u32 {
    type Output = Quantity<u32, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for u64 {
    type Output = Quantity<u64, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for u128 {
    type Output = Quantity<u128, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for usize {
    type Output = Quantity<usize, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for f32 {
    type Output = Quantity<f32, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
impl Mul<UnitZeptoergsMul> for f64 {
    type Output = Quantity<f64, UnitZeptoergs>;
    fn mul(self, _: UnitZeptoergsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoergs)
    }
}
pub struct UnitYoctoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoergs {
    #[inline]
    fn clone(&self) -> UnitYoctoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoergs {
    #[inline]
    fn eq(&self, other: &UnitYoctoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoergs {
    fn default() -> Self {
        UnitYoctoergs
    }
}
impl Add<UnitYoctoergs> for UnitYoctoergs {
    type Output = UnitYoctoergs;
    #[inline]
    fn add(self, _: UnitYoctoergs) -> Self::Output {
        UnitYoctoergs
    }
}
impl AddAssign<UnitYoctoergs> for UnitYoctoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoergs) {}
}
impl Sub<UnitYoctoergs> for UnitYoctoergs {
    type Output = UnitYoctoergs;
    #[inline]
    fn sub(self, _: UnitYoctoergs) -> Self::Output {
        UnitYoctoergs
    }
}
impl SubAssign<UnitYoctoergs> for UnitYoctoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoergs) {}
}
pub struct UnitYoctoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoergsMul {
    #[inline]
    fn clone(&self) -> UnitYoctoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoergsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoergsMul> for i8 {
    type Output = Quantity<i8, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for i16 {
    type Output = Quantity<i16, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for i32 {
    type Output = Quantity<i32, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for i64 {
    type Output = Quantity<i64, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for i128 {
    type Output = Quantity<i128, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for isize {
    type Output = Quantity<isize, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for u8 {
    type Output = Quantity<u8, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for u16 {
    type Output = Quantity<u16, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for u32 {
    type Output = Quantity<u32, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for u64 {
    type Output = Quantity<u64, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for u128 {
    type Output = Quantity<u128, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for usize {
    type Output = Quantity<usize, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for f32 {
    type Output = Quantity<f32, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
impl Mul<UnitYoctoergsMul> for f64 {
    type Output = Quantity<f64, UnitYoctoergs>;
    fn mul(self, _: UnitYoctoergsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoergs)
    }
}
pub struct UnitRontoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoergs {
    #[inline]
    fn clone(&self) -> UnitRontoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoergs {
    #[inline]
    fn eq(&self, other: &UnitRontoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoergs {
    fn default() -> Self {
        UnitRontoergs
    }
}
impl Add<UnitRontoergs> for UnitRontoergs {
    type Output = UnitRontoergs;
    #[inline]
    fn add(self, _: UnitRontoergs) -> Self::Output {
        UnitRontoergs
    }
}
impl AddAssign<UnitRontoergs> for UnitRontoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoergs) {}
}
impl Sub<UnitRontoergs> for UnitRontoergs {
    type Output = UnitRontoergs;
    #[inline]
    fn sub(self, _: UnitRontoergs) -> Self::Output {
        UnitRontoergs
    }
}
impl SubAssign<UnitRontoergs> for UnitRontoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoergs) {}
}
pub struct UnitRontoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoergsMul {
    #[inline]
    fn clone(&self) -> UnitRontoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoergsMul {
    #[inline]
    fn eq(&self, other: &UnitRontoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoergsMul> for i8 {
    type Output = Quantity<i8, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for i16 {
    type Output = Quantity<i16, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for i32 {
    type Output = Quantity<i32, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for i64 {
    type Output = Quantity<i64, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for i128 {
    type Output = Quantity<i128, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for isize {
    type Output = Quantity<isize, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for u8 {
    type Output = Quantity<u8, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for u16 {
    type Output = Quantity<u16, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for u32 {
    type Output = Quantity<u32, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for u64 {
    type Output = Quantity<u64, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for u128 {
    type Output = Quantity<u128, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for usize {
    type Output = Quantity<usize, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for f32 {
    type Output = Quantity<f32, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
impl Mul<UnitRontoergsMul> for f64 {
    type Output = Quantity<f64, UnitRontoergs>;
    fn mul(self, _: UnitRontoergsMul) -> Self::Output {
        Quantity::new(self, UnitRontoergs)
    }
}
pub struct UnitQuectoergs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoergs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoergs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoergs {
    #[inline]
    fn clone(&self) -> UnitQuectoergs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoergs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoergs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoergs {
    #[inline]
    fn eq(&self, other: &UnitQuectoergs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoergs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoergs {
    fn default() -> Self {
        UnitQuectoergs
    }
}
impl Add<UnitQuectoergs> for UnitQuectoergs {
    type Output = UnitQuectoergs;
    #[inline]
    fn add(self, _: UnitQuectoergs) -> Self::Output {
        UnitQuectoergs
    }
}
impl AddAssign<UnitQuectoergs> for UnitQuectoergs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoergs) {}
}
impl Sub<UnitQuectoergs> for UnitQuectoergs {
    type Output = UnitQuectoergs;
    #[inline]
    fn sub(self, _: UnitQuectoergs) -> Self::Output {
        UnitQuectoergs
    }
}
impl SubAssign<UnitQuectoergs> for UnitQuectoergs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoergs) {}
}
pub struct UnitQuectoergsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoergsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoergsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoergsMul {
    #[inline]
    fn clone(&self) -> UnitQuectoergsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoergsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoergsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoergsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoergsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoergsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoergsMul> for i8 {
    type Output = Quantity<i8, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for i16 {
    type Output = Quantity<i16, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for i32 {
    type Output = Quantity<i32, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for i64 {
    type Output = Quantity<i64, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for i128 {
    type Output = Quantity<i128, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for isize {
    type Output = Quantity<isize, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for u8 {
    type Output = Quantity<u8, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for u16 {
    type Output = Quantity<u16, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for u32 {
    type Output = Quantity<u32, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for u64 {
    type Output = Quantity<u64, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for u128 {
    type Output = Quantity<u128, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for usize {
    type Output = Quantity<usize, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for f32 {
    type Output = Quantity<f32, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
impl Mul<UnitQuectoergsMul> for f64 {
    type Output = Quantity<f64, UnitQuectoergs>;
    fn mul(self, _: UnitQuectoergsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoergs)
    }
}
pub type Ergs<T> = Quantity<T, UnitErgs>;
#[allow(non_upper_case_globals)]
pub static Ergs: UnitErgsMul = UnitErgsMul;
pub type Quettaergs<T> = Quantity<T, UnitQuettaergs>;
#[allow(non_upper_case_globals)]
pub static Quettaergs: UnitQuettaergsMul = UnitQuettaergsMul;
pub type Ronnaergs<T> = Quantity<T, UnitRonnaergs>;
#[allow(non_upper_case_globals)]
pub static Ronnaergs: UnitRonnaergsMul = UnitRonnaergsMul;
pub type Yottaergs<T> = Quantity<T, UnitYottaergs>;
#[allow(non_upper_case_globals)]
pub static Yottaergs: UnitYottaergsMul = UnitYottaergsMul;
pub type Zettaergs<T> = Quantity<T, UnitZettaergs>;
#[allow(non_upper_case_globals)]
pub static Zettaergs: UnitZettaergsMul = UnitZettaergsMul;
pub type Exaergs<T> = Quantity<T, UnitExaergs>;
#[allow(non_upper_case_globals)]
pub static Exaergs: UnitExaergsMul = UnitExaergsMul;
pub type Petaergs<T> = Quantity<T, UnitPetaergs>;
#[allow(non_upper_case_globals)]
pub static Petaergs: UnitPetaergsMul = UnitPetaergsMul;
pub type Teraergs<T> = Quantity<T, UnitTeraergs>;
#[allow(non_upper_case_globals)]
pub static Teraergs: UnitTeraergsMul = UnitTeraergsMul;
pub type Gigaergs<T> = Quantity<T, UnitGigaergs>;
#[allow(non_upper_case_globals)]
pub static Gigaergs: UnitGigaergsMul = UnitGigaergsMul;
pub type Megaergs<T> = Quantity<T, UnitMegaergs>;
#[allow(non_upper_case_globals)]
pub static Megaergs: UnitMegaergsMul = UnitMegaergsMul;
pub type Kiloergs<T> = Quantity<T, UnitKiloergs>;
#[allow(non_upper_case_globals)]
pub static Kiloergs: UnitKiloergsMul = UnitKiloergsMul;
pub type Hectoergs<T> = Quantity<T, UnitHectoergs>;
#[allow(non_upper_case_globals)]
pub static Hectoergs: UnitHectoergsMul = UnitHectoergsMul;
pub type Decaergs<T> = Quantity<T, UnitDecaergs>;
#[allow(non_upper_case_globals)]
pub static Decaergs: UnitDecaergsMul = UnitDecaergsMul;
pub type Deciergs<T> = Quantity<T, UnitDeciergs>;
#[allow(non_upper_case_globals)]
pub static Deciergs: UnitDeciergsMul = UnitDeciergsMul;
pub type Centiergs<T> = Quantity<T, UnitCentiergs>;
#[allow(non_upper_case_globals)]
pub static Centiergs: UnitCentiergsMul = UnitCentiergsMul;
pub type Milliergs<T> = Quantity<T, UnitMilliergs>;
#[allow(non_upper_case_globals)]
pub static Milliergs: UnitMilliergsMul = UnitMilliergsMul;
pub type Microergs<T> = Quantity<T, UnitMicroergs>;
#[allow(non_upper_case_globals)]
pub static Microergs: UnitMicroergsMul = UnitMicroergsMul;
pub type Nanoergs<T> = Quantity<T, UnitNanoergs>;
#[allow(non_upper_case_globals)]
pub static Nanoergs: UnitNanoergsMul = UnitNanoergsMul;
pub type Picoergs<T> = Quantity<T, UnitPicoergs>;
#[allow(non_upper_case_globals)]
pub static Picoergs: UnitPicoergsMul = UnitPicoergsMul;
pub type Femtoergs<T> = Quantity<T, UnitFemtoergs>;
#[allow(non_upper_case_globals)]
pub static Femtoergs: UnitFemtoergsMul = UnitFemtoergsMul;
pub type Attoergs<T> = Quantity<T, UnitAttoergs>;
#[allow(non_upper_case_globals)]
pub static Attoergs: UnitAttoergsMul = UnitAttoergsMul;
pub type Zeptoergs<T> = Quantity<T, UnitZeptoergs>;
#[allow(non_upper_case_globals)]
pub static Zeptoergs: UnitZeptoergsMul = UnitZeptoergsMul;
pub type Yoctoergs<T> = Quantity<T, UnitYoctoergs>;
#[allow(non_upper_case_globals)]
pub static Yoctoergs: UnitYoctoergsMul = UnitYoctoergsMul;
pub type Rontoergs<T> = Quantity<T, UnitRontoergs>;
#[allow(non_upper_case_globals)]
pub static Rontoergs: UnitRontoergsMul = UnitRontoergsMul;
pub type Quectoergs<T> = Quantity<T, UnitQuectoergs>;
#[allow(non_upper_case_globals)]
pub static Quectoergs: UnitQuectoergsMul = UnitQuectoergsMul;
pub struct UnitPoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPoises {
    #[inline]
    fn clone(&self) -> UnitPoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPoises {
    #[inline]
    fn eq(&self, other: &UnitPoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPoises {
    fn default() -> Self {
        UnitPoises
    }
}
impl Add<UnitPoises> for UnitPoises {
    type Output = UnitPoises;
    #[inline]
    fn add(self, _: UnitPoises) -> Self::Output {
        UnitPoises
    }
}
impl AddAssign<UnitPoises> for UnitPoises {
    #[inline]
    fn add_assign(&mut self, _: UnitPoises) {}
}
impl Sub<UnitPoises> for UnitPoises {
    type Output = UnitPoises;
    #[inline]
    fn sub(self, _: UnitPoises) -> Self::Output {
        UnitPoises
    }
}
impl SubAssign<UnitPoises> for UnitPoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitPoises) {}
}
pub struct UnitPoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPoisesMul {
    #[inline]
    fn clone(&self) -> UnitPoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPoisesMul {
    #[inline]
    fn eq(&self, other: &UnitPoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPoisesMul> for i8 {
    type Output = Quantity<i8, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for i16 {
    type Output = Quantity<i16, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for i32 {
    type Output = Quantity<i32, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for i64 {
    type Output = Quantity<i64, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for i128 {
    type Output = Quantity<i128, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for isize {
    type Output = Quantity<isize, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for u8 {
    type Output = Quantity<u8, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for u16 {
    type Output = Quantity<u16, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for u32 {
    type Output = Quantity<u32, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for u64 {
    type Output = Quantity<u64, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for u128 {
    type Output = Quantity<u128, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for usize {
    type Output = Quantity<usize, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for f32 {
    type Output = Quantity<f32, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
impl Mul<UnitPoisesMul> for f64 {
    type Output = Quantity<f64, UnitPoises>;
    fn mul(self, _: UnitPoisesMul) -> Self::Output {
        Quantity::new(self, UnitPoises)
    }
}
pub struct UnitQuettapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettapoises {
    #[inline]
    fn clone(&self) -> UnitQuettapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettapoises {
    #[inline]
    fn eq(&self, other: &UnitQuettapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettapoises {
    fn default() -> Self {
        UnitQuettapoises
    }
}
impl Add<UnitQuettapoises> for UnitQuettapoises {
    type Output = UnitQuettapoises;
    #[inline]
    fn add(self, _: UnitQuettapoises) -> Self::Output {
        UnitQuettapoises
    }
}
impl AddAssign<UnitQuettapoises> for UnitQuettapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettapoises) {}
}
impl Sub<UnitQuettapoises> for UnitQuettapoises {
    type Output = UnitQuettapoises;
    #[inline]
    fn sub(self, _: UnitQuettapoises) -> Self::Output {
        UnitQuettapoises
    }
}
impl SubAssign<UnitQuettapoises> for UnitQuettapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettapoises) {}
}
pub struct UnitQuettapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettapoisesMul {
    #[inline]
    fn clone(&self) -> UnitQuettapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettapoisesMul> for i8 {
    type Output = Quantity<i8, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for i16 {
    type Output = Quantity<i16, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for i32 {
    type Output = Quantity<i32, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for i64 {
    type Output = Quantity<i64, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for i128 {
    type Output = Quantity<i128, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for isize {
    type Output = Quantity<isize, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for u8 {
    type Output = Quantity<u8, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for u16 {
    type Output = Quantity<u16, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for u32 {
    type Output = Quantity<u32, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for u64 {
    type Output = Quantity<u64, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for u128 {
    type Output = Quantity<u128, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for usize {
    type Output = Quantity<usize, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for f32 {
    type Output = Quantity<f32, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
impl Mul<UnitQuettapoisesMul> for f64 {
    type Output = Quantity<f64, UnitQuettapoises>;
    fn mul(self, _: UnitQuettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuettapoises)
    }
}
pub struct UnitRonnapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnapoises {
    #[inline]
    fn clone(&self) -> UnitRonnapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnapoises {
    #[inline]
    fn eq(&self, other: &UnitRonnapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnapoises {
    fn default() -> Self {
        UnitRonnapoises
    }
}
impl Add<UnitRonnapoises> for UnitRonnapoises {
    type Output = UnitRonnapoises;
    #[inline]
    fn add(self, _: UnitRonnapoises) -> Self::Output {
        UnitRonnapoises
    }
}
impl AddAssign<UnitRonnapoises> for UnitRonnapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnapoises) {}
}
impl Sub<UnitRonnapoises> for UnitRonnapoises {
    type Output = UnitRonnapoises;
    #[inline]
    fn sub(self, _: UnitRonnapoises) -> Self::Output {
        UnitRonnapoises
    }
}
impl SubAssign<UnitRonnapoises> for UnitRonnapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnapoises) {}
}
pub struct UnitRonnapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnapoisesMul {
    #[inline]
    fn clone(&self) -> UnitRonnapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnapoisesMul> for i8 {
    type Output = Quantity<i8, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for i16 {
    type Output = Quantity<i16, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for i32 {
    type Output = Quantity<i32, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for i64 {
    type Output = Quantity<i64, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for i128 {
    type Output = Quantity<i128, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for isize {
    type Output = Quantity<isize, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for u8 {
    type Output = Quantity<u8, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for u16 {
    type Output = Quantity<u16, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for u32 {
    type Output = Quantity<u32, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for u64 {
    type Output = Quantity<u64, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for u128 {
    type Output = Quantity<u128, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for usize {
    type Output = Quantity<usize, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for f32 {
    type Output = Quantity<f32, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
impl Mul<UnitRonnapoisesMul> for f64 {
    type Output = Quantity<f64, UnitRonnapoises>;
    fn mul(self, _: UnitRonnapoisesMul) -> Self::Output {
        Quantity::new(self, UnitRonnapoises)
    }
}
pub struct UnitYottapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottapoises {
    #[inline]
    fn clone(&self) -> UnitYottapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottapoises {
    #[inline]
    fn eq(&self, other: &UnitYottapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottapoises {
    fn default() -> Self {
        UnitYottapoises
    }
}
impl Add<UnitYottapoises> for UnitYottapoises {
    type Output = UnitYottapoises;
    #[inline]
    fn add(self, _: UnitYottapoises) -> Self::Output {
        UnitYottapoises
    }
}
impl AddAssign<UnitYottapoises> for UnitYottapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitYottapoises) {}
}
impl Sub<UnitYottapoises> for UnitYottapoises {
    type Output = UnitYottapoises;
    #[inline]
    fn sub(self, _: UnitYottapoises) -> Self::Output {
        UnitYottapoises
    }
}
impl SubAssign<UnitYottapoises> for UnitYottapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottapoises) {}
}
pub struct UnitYottapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottapoisesMul {
    #[inline]
    fn clone(&self) -> UnitYottapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitYottapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottapoisesMul> for i8 {
    type Output = Quantity<i8, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for i16 {
    type Output = Quantity<i16, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for i32 {
    type Output = Quantity<i32, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for i64 {
    type Output = Quantity<i64, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for i128 {
    type Output = Quantity<i128, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for isize {
    type Output = Quantity<isize, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for u8 {
    type Output = Quantity<u8, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for u16 {
    type Output = Quantity<u16, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for u32 {
    type Output = Quantity<u32, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for u64 {
    type Output = Quantity<u64, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for u128 {
    type Output = Quantity<u128, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for usize {
    type Output = Quantity<usize, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for f32 {
    type Output = Quantity<f32, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
impl Mul<UnitYottapoisesMul> for f64 {
    type Output = Quantity<f64, UnitYottapoises>;
    fn mul(self, _: UnitYottapoisesMul) -> Self::Output {
        Quantity::new(self, UnitYottapoises)
    }
}
pub struct UnitZettapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettapoises {
    #[inline]
    fn clone(&self) -> UnitZettapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettapoises {
    #[inline]
    fn eq(&self, other: &UnitZettapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettapoises {
    fn default() -> Self {
        UnitZettapoises
    }
}
impl Add<UnitZettapoises> for UnitZettapoises {
    type Output = UnitZettapoises;
    #[inline]
    fn add(self, _: UnitZettapoises) -> Self::Output {
        UnitZettapoises
    }
}
impl AddAssign<UnitZettapoises> for UnitZettapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitZettapoises) {}
}
impl Sub<UnitZettapoises> for UnitZettapoises {
    type Output = UnitZettapoises;
    #[inline]
    fn sub(self, _: UnitZettapoises) -> Self::Output {
        UnitZettapoises
    }
}
impl SubAssign<UnitZettapoises> for UnitZettapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettapoises) {}
}
pub struct UnitZettapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettapoisesMul {
    #[inline]
    fn clone(&self) -> UnitZettapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitZettapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettapoisesMul> for i8 {
    type Output = Quantity<i8, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for i16 {
    type Output = Quantity<i16, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for i32 {
    type Output = Quantity<i32, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for i64 {
    type Output = Quantity<i64, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for i128 {
    type Output = Quantity<i128, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for isize {
    type Output = Quantity<isize, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for u8 {
    type Output = Quantity<u8, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for u16 {
    type Output = Quantity<u16, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for u32 {
    type Output = Quantity<u32, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for u64 {
    type Output = Quantity<u64, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for u128 {
    type Output = Quantity<u128, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for usize {
    type Output = Quantity<usize, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for f32 {
    type Output = Quantity<f32, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
impl Mul<UnitZettapoisesMul> for f64 {
    type Output = Quantity<f64, UnitZettapoises>;
    fn mul(self, _: UnitZettapoisesMul) -> Self::Output {
        Quantity::new(self, UnitZettapoises)
    }
}
pub struct UnitExapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExapoises {
    #[inline]
    fn clone(&self) -> UnitExapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExapoises {
    #[inline]
    fn eq(&self, other: &UnitExapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExapoises {
    fn default() -> Self {
        UnitExapoises
    }
}
impl Add<UnitExapoises> for UnitExapoises {
    type Output = UnitExapoises;
    #[inline]
    fn add(self, _: UnitExapoises) -> Self::Output {
        UnitExapoises
    }
}
impl AddAssign<UnitExapoises> for UnitExapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitExapoises) {}
}
impl Sub<UnitExapoises> for UnitExapoises {
    type Output = UnitExapoises;
    #[inline]
    fn sub(self, _: UnitExapoises) -> Self::Output {
        UnitExapoises
    }
}
impl SubAssign<UnitExapoises> for UnitExapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitExapoises) {}
}
pub struct UnitExapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExapoisesMul {
    #[inline]
    fn clone(&self) -> UnitExapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitExapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExapoisesMul> for i8 {
    type Output = Quantity<i8, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for i16 {
    type Output = Quantity<i16, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for i32 {
    type Output = Quantity<i32, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for i64 {
    type Output = Quantity<i64, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for i128 {
    type Output = Quantity<i128, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for isize {
    type Output = Quantity<isize, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for u8 {
    type Output = Quantity<u8, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for u16 {
    type Output = Quantity<u16, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for u32 {
    type Output = Quantity<u32, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for u64 {
    type Output = Quantity<u64, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for u128 {
    type Output = Quantity<u128, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for usize {
    type Output = Quantity<usize, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for f32 {
    type Output = Quantity<f32, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
impl Mul<UnitExapoisesMul> for f64 {
    type Output = Quantity<f64, UnitExapoises>;
    fn mul(self, _: UnitExapoisesMul) -> Self::Output {
        Quantity::new(self, UnitExapoises)
    }
}
pub struct UnitPetapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetapoises {
    #[inline]
    fn clone(&self) -> UnitPetapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetapoises {
    #[inline]
    fn eq(&self, other: &UnitPetapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetapoises {
    fn default() -> Self {
        UnitPetapoises
    }
}
impl Add<UnitPetapoises> for UnitPetapoises {
    type Output = UnitPetapoises;
    #[inline]
    fn add(self, _: UnitPetapoises) -> Self::Output {
        UnitPetapoises
    }
}
impl AddAssign<UnitPetapoises> for UnitPetapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitPetapoises) {}
}
impl Sub<UnitPetapoises> for UnitPetapoises {
    type Output = UnitPetapoises;
    #[inline]
    fn sub(self, _: UnitPetapoises) -> Self::Output {
        UnitPetapoises
    }
}
impl SubAssign<UnitPetapoises> for UnitPetapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetapoises) {}
}
pub struct UnitPetapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetapoisesMul {
    #[inline]
    fn clone(&self) -> UnitPetapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitPetapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetapoisesMul> for i8 {
    type Output = Quantity<i8, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for i16 {
    type Output = Quantity<i16, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for i32 {
    type Output = Quantity<i32, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for i64 {
    type Output = Quantity<i64, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for i128 {
    type Output = Quantity<i128, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for isize {
    type Output = Quantity<isize, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for u8 {
    type Output = Quantity<u8, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for u16 {
    type Output = Quantity<u16, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for u32 {
    type Output = Quantity<u32, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for u64 {
    type Output = Quantity<u64, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for u128 {
    type Output = Quantity<u128, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for usize {
    type Output = Quantity<usize, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for f32 {
    type Output = Quantity<f32, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
impl Mul<UnitPetapoisesMul> for f64 {
    type Output = Quantity<f64, UnitPetapoises>;
    fn mul(self, _: UnitPetapoisesMul) -> Self::Output {
        Quantity::new(self, UnitPetapoises)
    }
}
pub struct UnitTerapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerapoises {
    #[inline]
    fn clone(&self) -> UnitTerapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerapoises {
    #[inline]
    fn eq(&self, other: &UnitTerapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerapoises {
    fn default() -> Self {
        UnitTerapoises
    }
}
impl Add<UnitTerapoises> for UnitTerapoises {
    type Output = UnitTerapoises;
    #[inline]
    fn add(self, _: UnitTerapoises) -> Self::Output {
        UnitTerapoises
    }
}
impl AddAssign<UnitTerapoises> for UnitTerapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitTerapoises) {}
}
impl Sub<UnitTerapoises> for UnitTerapoises {
    type Output = UnitTerapoises;
    #[inline]
    fn sub(self, _: UnitTerapoises) -> Self::Output {
        UnitTerapoises
    }
}
impl SubAssign<UnitTerapoises> for UnitTerapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerapoises) {}
}
pub struct UnitTerapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerapoisesMul {
    #[inline]
    fn clone(&self) -> UnitTerapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitTerapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerapoisesMul> for i8 {
    type Output = Quantity<i8, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for i16 {
    type Output = Quantity<i16, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for i32 {
    type Output = Quantity<i32, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for i64 {
    type Output = Quantity<i64, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for i128 {
    type Output = Quantity<i128, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for isize {
    type Output = Quantity<isize, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for u8 {
    type Output = Quantity<u8, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for u16 {
    type Output = Quantity<u16, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for u32 {
    type Output = Quantity<u32, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for u64 {
    type Output = Quantity<u64, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for u128 {
    type Output = Quantity<u128, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for usize {
    type Output = Quantity<usize, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for f32 {
    type Output = Quantity<f32, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
impl Mul<UnitTerapoisesMul> for f64 {
    type Output = Quantity<f64, UnitTerapoises>;
    fn mul(self, _: UnitTerapoisesMul) -> Self::Output {
        Quantity::new(self, UnitTerapoises)
    }
}
pub struct UnitGigapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigapoises {
    #[inline]
    fn clone(&self) -> UnitGigapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigapoises {
    #[inline]
    fn eq(&self, other: &UnitGigapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigapoises {
    fn default() -> Self {
        UnitGigapoises
    }
}
impl Add<UnitGigapoises> for UnitGigapoises {
    type Output = UnitGigapoises;
    #[inline]
    fn add(self, _: UnitGigapoises) -> Self::Output {
        UnitGigapoises
    }
}
impl AddAssign<UnitGigapoises> for UnitGigapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitGigapoises) {}
}
impl Sub<UnitGigapoises> for UnitGigapoises {
    type Output = UnitGigapoises;
    #[inline]
    fn sub(self, _: UnitGigapoises) -> Self::Output {
        UnitGigapoises
    }
}
impl SubAssign<UnitGigapoises> for UnitGigapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigapoises) {}
}
pub struct UnitGigapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigapoisesMul {
    #[inline]
    fn clone(&self) -> UnitGigapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitGigapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigapoisesMul> for i8 {
    type Output = Quantity<i8, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for i16 {
    type Output = Quantity<i16, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for i32 {
    type Output = Quantity<i32, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for i64 {
    type Output = Quantity<i64, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for i128 {
    type Output = Quantity<i128, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for isize {
    type Output = Quantity<isize, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for u8 {
    type Output = Quantity<u8, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for u16 {
    type Output = Quantity<u16, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for u32 {
    type Output = Quantity<u32, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for u64 {
    type Output = Quantity<u64, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for u128 {
    type Output = Quantity<u128, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for usize {
    type Output = Quantity<usize, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for f32 {
    type Output = Quantity<f32, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
impl Mul<UnitGigapoisesMul> for f64 {
    type Output = Quantity<f64, UnitGigapoises>;
    fn mul(self, _: UnitGigapoisesMul) -> Self::Output {
        Quantity::new(self, UnitGigapoises)
    }
}
pub struct UnitMegapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegapoises {
    #[inline]
    fn clone(&self) -> UnitMegapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegapoises {
    #[inline]
    fn eq(&self, other: &UnitMegapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegapoises {
    fn default() -> Self {
        UnitMegapoises
    }
}
impl Add<UnitMegapoises> for UnitMegapoises {
    type Output = UnitMegapoises;
    #[inline]
    fn add(self, _: UnitMegapoises) -> Self::Output {
        UnitMegapoises
    }
}
impl AddAssign<UnitMegapoises> for UnitMegapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitMegapoises) {}
}
impl Sub<UnitMegapoises> for UnitMegapoises {
    type Output = UnitMegapoises;
    #[inline]
    fn sub(self, _: UnitMegapoises) -> Self::Output {
        UnitMegapoises
    }
}
impl SubAssign<UnitMegapoises> for UnitMegapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegapoises) {}
}
pub struct UnitMegapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegapoisesMul {
    #[inline]
    fn clone(&self) -> UnitMegapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitMegapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegapoisesMul> for i8 {
    type Output = Quantity<i8, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for i16 {
    type Output = Quantity<i16, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for i32 {
    type Output = Quantity<i32, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for i64 {
    type Output = Quantity<i64, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for i128 {
    type Output = Quantity<i128, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for isize {
    type Output = Quantity<isize, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for u8 {
    type Output = Quantity<u8, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for u16 {
    type Output = Quantity<u16, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for u32 {
    type Output = Quantity<u32, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for u64 {
    type Output = Quantity<u64, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for u128 {
    type Output = Quantity<u128, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for usize {
    type Output = Quantity<usize, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for f32 {
    type Output = Quantity<f32, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
impl Mul<UnitMegapoisesMul> for f64 {
    type Output = Quantity<f64, UnitMegapoises>;
    fn mul(self, _: UnitMegapoisesMul) -> Self::Output {
        Quantity::new(self, UnitMegapoises)
    }
}
pub struct UnitKilopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilopoises {
    #[inline]
    fn clone(&self) -> UnitKilopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilopoises {
    #[inline]
    fn eq(&self, other: &UnitKilopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilopoises {
    fn default() -> Self {
        UnitKilopoises
    }
}
impl Add<UnitKilopoises> for UnitKilopoises {
    type Output = UnitKilopoises;
    #[inline]
    fn add(self, _: UnitKilopoises) -> Self::Output {
        UnitKilopoises
    }
}
impl AddAssign<UnitKilopoises> for UnitKilopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitKilopoises) {}
}
impl Sub<UnitKilopoises> for UnitKilopoises {
    type Output = UnitKilopoises;
    #[inline]
    fn sub(self, _: UnitKilopoises) -> Self::Output {
        UnitKilopoises
    }
}
impl SubAssign<UnitKilopoises> for UnitKilopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilopoises) {}
}
pub struct UnitKilopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilopoisesMul {
    #[inline]
    fn clone(&self) -> UnitKilopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitKilopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilopoisesMul> for i8 {
    type Output = Quantity<i8, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for i16 {
    type Output = Quantity<i16, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for i32 {
    type Output = Quantity<i32, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for i64 {
    type Output = Quantity<i64, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for i128 {
    type Output = Quantity<i128, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for isize {
    type Output = Quantity<isize, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for u8 {
    type Output = Quantity<u8, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for u16 {
    type Output = Quantity<u16, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for u32 {
    type Output = Quantity<u32, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for u64 {
    type Output = Quantity<u64, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for u128 {
    type Output = Quantity<u128, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for usize {
    type Output = Quantity<usize, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for f32 {
    type Output = Quantity<f32, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
impl Mul<UnitKilopoisesMul> for f64 {
    type Output = Quantity<f64, UnitKilopoises>;
    fn mul(self, _: UnitKilopoisesMul) -> Self::Output {
        Quantity::new(self, UnitKilopoises)
    }
}
pub struct UnitHectopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectopoises {
    #[inline]
    fn clone(&self) -> UnitHectopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectopoises {
    #[inline]
    fn eq(&self, other: &UnitHectopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectopoises {
    fn default() -> Self {
        UnitHectopoises
    }
}
impl Add<UnitHectopoises> for UnitHectopoises {
    type Output = UnitHectopoises;
    #[inline]
    fn add(self, _: UnitHectopoises) -> Self::Output {
        UnitHectopoises
    }
}
impl AddAssign<UnitHectopoises> for UnitHectopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitHectopoises) {}
}
impl Sub<UnitHectopoises> for UnitHectopoises {
    type Output = UnitHectopoises;
    #[inline]
    fn sub(self, _: UnitHectopoises) -> Self::Output {
        UnitHectopoises
    }
}
impl SubAssign<UnitHectopoises> for UnitHectopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectopoises) {}
}
pub struct UnitHectopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectopoisesMul {
    #[inline]
    fn clone(&self) -> UnitHectopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitHectopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectopoisesMul> for i8 {
    type Output = Quantity<i8, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for i16 {
    type Output = Quantity<i16, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for i32 {
    type Output = Quantity<i32, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for i64 {
    type Output = Quantity<i64, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for i128 {
    type Output = Quantity<i128, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for isize {
    type Output = Quantity<isize, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for u8 {
    type Output = Quantity<u8, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for u16 {
    type Output = Quantity<u16, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for u32 {
    type Output = Quantity<u32, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for u64 {
    type Output = Quantity<u64, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for u128 {
    type Output = Quantity<u128, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for usize {
    type Output = Quantity<usize, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for f32 {
    type Output = Quantity<f32, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
impl Mul<UnitHectopoisesMul> for f64 {
    type Output = Quantity<f64, UnitHectopoises>;
    fn mul(self, _: UnitHectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitHectopoises)
    }
}
pub struct UnitDecapoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecapoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecapoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecapoises {
    #[inline]
    fn clone(&self) -> UnitDecapoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecapoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecapoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecapoises {
    #[inline]
    fn eq(&self, other: &UnitDecapoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecapoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecapoises {
    fn default() -> Self {
        UnitDecapoises
    }
}
impl Add<UnitDecapoises> for UnitDecapoises {
    type Output = UnitDecapoises;
    #[inline]
    fn add(self, _: UnitDecapoises) -> Self::Output {
        UnitDecapoises
    }
}
impl AddAssign<UnitDecapoises> for UnitDecapoises {
    #[inline]
    fn add_assign(&mut self, _: UnitDecapoises) {}
}
impl Sub<UnitDecapoises> for UnitDecapoises {
    type Output = UnitDecapoises;
    #[inline]
    fn sub(self, _: UnitDecapoises) -> Self::Output {
        UnitDecapoises
    }
}
impl SubAssign<UnitDecapoises> for UnitDecapoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecapoises) {}
}
pub struct UnitDecapoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecapoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecapoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecapoisesMul {
    #[inline]
    fn clone(&self) -> UnitDecapoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecapoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecapoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecapoisesMul {
    #[inline]
    fn eq(&self, other: &UnitDecapoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecapoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecapoisesMul> for i8 {
    type Output = Quantity<i8, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for i16 {
    type Output = Quantity<i16, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for i32 {
    type Output = Quantity<i32, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for i64 {
    type Output = Quantity<i64, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for i128 {
    type Output = Quantity<i128, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for isize {
    type Output = Quantity<isize, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for u8 {
    type Output = Quantity<u8, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for u16 {
    type Output = Quantity<u16, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for u32 {
    type Output = Quantity<u32, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for u64 {
    type Output = Quantity<u64, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for u128 {
    type Output = Quantity<u128, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for usize {
    type Output = Quantity<usize, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for f32 {
    type Output = Quantity<f32, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
impl Mul<UnitDecapoisesMul> for f64 {
    type Output = Quantity<f64, UnitDecapoises>;
    fn mul(self, _: UnitDecapoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecapoises)
    }
}
pub struct UnitDecipoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecipoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecipoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecipoises {
    #[inline]
    fn clone(&self) -> UnitDecipoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecipoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecipoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecipoises {
    #[inline]
    fn eq(&self, other: &UnitDecipoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecipoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecipoises {
    fn default() -> Self {
        UnitDecipoises
    }
}
impl Add<UnitDecipoises> for UnitDecipoises {
    type Output = UnitDecipoises;
    #[inline]
    fn add(self, _: UnitDecipoises) -> Self::Output {
        UnitDecipoises
    }
}
impl AddAssign<UnitDecipoises> for UnitDecipoises {
    #[inline]
    fn add_assign(&mut self, _: UnitDecipoises) {}
}
impl Sub<UnitDecipoises> for UnitDecipoises {
    type Output = UnitDecipoises;
    #[inline]
    fn sub(self, _: UnitDecipoises) -> Self::Output {
        UnitDecipoises
    }
}
impl SubAssign<UnitDecipoises> for UnitDecipoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecipoises) {}
}
pub struct UnitDecipoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecipoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecipoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecipoisesMul {
    #[inline]
    fn clone(&self) -> UnitDecipoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecipoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecipoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecipoisesMul {
    #[inline]
    fn eq(&self, other: &UnitDecipoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecipoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecipoisesMul> for i8 {
    type Output = Quantity<i8, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for i16 {
    type Output = Quantity<i16, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for i32 {
    type Output = Quantity<i32, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for i64 {
    type Output = Quantity<i64, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for i128 {
    type Output = Quantity<i128, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for isize {
    type Output = Quantity<isize, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for u8 {
    type Output = Quantity<u8, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for u16 {
    type Output = Quantity<u16, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for u32 {
    type Output = Quantity<u32, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for u64 {
    type Output = Quantity<u64, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for u128 {
    type Output = Quantity<u128, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for usize {
    type Output = Quantity<usize, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for f32 {
    type Output = Quantity<f32, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
impl Mul<UnitDecipoisesMul> for f64 {
    type Output = Quantity<f64, UnitDecipoises>;
    fn mul(self, _: UnitDecipoisesMul) -> Self::Output {
        Quantity::new(self, UnitDecipoises)
    }
}
pub struct UnitCentipoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentipoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentipoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentipoises {
    #[inline]
    fn clone(&self) -> UnitCentipoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentipoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentipoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentipoises {
    #[inline]
    fn eq(&self, other: &UnitCentipoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentipoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentipoises {
    fn default() -> Self {
        UnitCentipoises
    }
}
impl Add<UnitCentipoises> for UnitCentipoises {
    type Output = UnitCentipoises;
    #[inline]
    fn add(self, _: UnitCentipoises) -> Self::Output {
        UnitCentipoises
    }
}
impl AddAssign<UnitCentipoises> for UnitCentipoises {
    #[inline]
    fn add_assign(&mut self, _: UnitCentipoises) {}
}
impl Sub<UnitCentipoises> for UnitCentipoises {
    type Output = UnitCentipoises;
    #[inline]
    fn sub(self, _: UnitCentipoises) -> Self::Output {
        UnitCentipoises
    }
}
impl SubAssign<UnitCentipoises> for UnitCentipoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentipoises) {}
}
pub struct UnitCentipoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentipoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentipoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentipoisesMul {
    #[inline]
    fn clone(&self) -> UnitCentipoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentipoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentipoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentipoisesMul {
    #[inline]
    fn eq(&self, other: &UnitCentipoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentipoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentipoisesMul> for i8 {
    type Output = Quantity<i8, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for i16 {
    type Output = Quantity<i16, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for i32 {
    type Output = Quantity<i32, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for i64 {
    type Output = Quantity<i64, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for i128 {
    type Output = Quantity<i128, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for isize {
    type Output = Quantity<isize, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for u8 {
    type Output = Quantity<u8, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for u16 {
    type Output = Quantity<u16, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for u32 {
    type Output = Quantity<u32, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for u64 {
    type Output = Quantity<u64, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for u128 {
    type Output = Quantity<u128, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for usize {
    type Output = Quantity<usize, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for f32 {
    type Output = Quantity<f32, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
impl Mul<UnitCentipoisesMul> for f64 {
    type Output = Quantity<f64, UnitCentipoises>;
    fn mul(self, _: UnitCentipoisesMul) -> Self::Output {
        Quantity::new(self, UnitCentipoises)
    }
}
pub struct UnitMillipoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillipoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillipoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillipoises {
    #[inline]
    fn clone(&self) -> UnitMillipoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillipoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillipoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillipoises {
    #[inline]
    fn eq(&self, other: &UnitMillipoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillipoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillipoises {
    fn default() -> Self {
        UnitMillipoises
    }
}
impl Add<UnitMillipoises> for UnitMillipoises {
    type Output = UnitMillipoises;
    #[inline]
    fn add(self, _: UnitMillipoises) -> Self::Output {
        UnitMillipoises
    }
}
impl AddAssign<UnitMillipoises> for UnitMillipoises {
    #[inline]
    fn add_assign(&mut self, _: UnitMillipoises) {}
}
impl Sub<UnitMillipoises> for UnitMillipoises {
    type Output = UnitMillipoises;
    #[inline]
    fn sub(self, _: UnitMillipoises) -> Self::Output {
        UnitMillipoises
    }
}
impl SubAssign<UnitMillipoises> for UnitMillipoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillipoises) {}
}
pub struct UnitMillipoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillipoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillipoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillipoisesMul {
    #[inline]
    fn clone(&self) -> UnitMillipoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillipoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillipoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillipoisesMul {
    #[inline]
    fn eq(&self, other: &UnitMillipoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillipoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillipoisesMul> for i8 {
    type Output = Quantity<i8, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for i16 {
    type Output = Quantity<i16, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for i32 {
    type Output = Quantity<i32, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for i64 {
    type Output = Quantity<i64, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for i128 {
    type Output = Quantity<i128, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for isize {
    type Output = Quantity<isize, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for u8 {
    type Output = Quantity<u8, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for u16 {
    type Output = Quantity<u16, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for u32 {
    type Output = Quantity<u32, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for u64 {
    type Output = Quantity<u64, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for u128 {
    type Output = Quantity<u128, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for usize {
    type Output = Quantity<usize, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for f32 {
    type Output = Quantity<f32, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
impl Mul<UnitMillipoisesMul> for f64 {
    type Output = Quantity<f64, UnitMillipoises>;
    fn mul(self, _: UnitMillipoisesMul) -> Self::Output {
        Quantity::new(self, UnitMillipoises)
    }
}
pub struct UnitMicropoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicropoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicropoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicropoises {
    #[inline]
    fn clone(&self) -> UnitMicropoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicropoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicropoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicropoises {
    #[inline]
    fn eq(&self, other: &UnitMicropoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicropoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicropoises {
    fn default() -> Self {
        UnitMicropoises
    }
}
impl Add<UnitMicropoises> for UnitMicropoises {
    type Output = UnitMicropoises;
    #[inline]
    fn add(self, _: UnitMicropoises) -> Self::Output {
        UnitMicropoises
    }
}
impl AddAssign<UnitMicropoises> for UnitMicropoises {
    #[inline]
    fn add_assign(&mut self, _: UnitMicropoises) {}
}
impl Sub<UnitMicropoises> for UnitMicropoises {
    type Output = UnitMicropoises;
    #[inline]
    fn sub(self, _: UnitMicropoises) -> Self::Output {
        UnitMicropoises
    }
}
impl SubAssign<UnitMicropoises> for UnitMicropoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicropoises) {}
}
pub struct UnitMicropoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicropoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicropoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicropoisesMul {
    #[inline]
    fn clone(&self) -> UnitMicropoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicropoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicropoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicropoisesMul {
    #[inline]
    fn eq(&self, other: &UnitMicropoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicropoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicropoisesMul> for i8 {
    type Output = Quantity<i8, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for i16 {
    type Output = Quantity<i16, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for i32 {
    type Output = Quantity<i32, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for i64 {
    type Output = Quantity<i64, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for i128 {
    type Output = Quantity<i128, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for isize {
    type Output = Quantity<isize, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for u8 {
    type Output = Quantity<u8, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for u16 {
    type Output = Quantity<u16, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for u32 {
    type Output = Quantity<u32, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for u64 {
    type Output = Quantity<u64, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for u128 {
    type Output = Quantity<u128, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for usize {
    type Output = Quantity<usize, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for f32 {
    type Output = Quantity<f32, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
impl Mul<UnitMicropoisesMul> for f64 {
    type Output = Quantity<f64, UnitMicropoises>;
    fn mul(self, _: UnitMicropoisesMul) -> Self::Output {
        Quantity::new(self, UnitMicropoises)
    }
}
pub struct UnitNanopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanopoises {
    #[inline]
    fn clone(&self) -> UnitNanopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanopoises {
    #[inline]
    fn eq(&self, other: &UnitNanopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanopoises {
    fn default() -> Self {
        UnitNanopoises
    }
}
impl Add<UnitNanopoises> for UnitNanopoises {
    type Output = UnitNanopoises;
    #[inline]
    fn add(self, _: UnitNanopoises) -> Self::Output {
        UnitNanopoises
    }
}
impl AddAssign<UnitNanopoises> for UnitNanopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitNanopoises) {}
}
impl Sub<UnitNanopoises> for UnitNanopoises {
    type Output = UnitNanopoises;
    #[inline]
    fn sub(self, _: UnitNanopoises) -> Self::Output {
        UnitNanopoises
    }
}
impl SubAssign<UnitNanopoises> for UnitNanopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanopoises) {}
}
pub struct UnitNanopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanopoisesMul {
    #[inline]
    fn clone(&self) -> UnitNanopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitNanopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanopoisesMul> for i8 {
    type Output = Quantity<i8, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for i16 {
    type Output = Quantity<i16, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for i32 {
    type Output = Quantity<i32, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for i64 {
    type Output = Quantity<i64, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for i128 {
    type Output = Quantity<i128, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for isize {
    type Output = Quantity<isize, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for u8 {
    type Output = Quantity<u8, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for u16 {
    type Output = Quantity<u16, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for u32 {
    type Output = Quantity<u32, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for u64 {
    type Output = Quantity<u64, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for u128 {
    type Output = Quantity<u128, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for usize {
    type Output = Quantity<usize, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for f32 {
    type Output = Quantity<f32, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
impl Mul<UnitNanopoisesMul> for f64 {
    type Output = Quantity<f64, UnitNanopoises>;
    fn mul(self, _: UnitNanopoisesMul) -> Self::Output {
        Quantity::new(self, UnitNanopoises)
    }
}
pub struct UnitPicopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicopoises {
    #[inline]
    fn clone(&self) -> UnitPicopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicopoises {
    #[inline]
    fn eq(&self, other: &UnitPicopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicopoises {
    fn default() -> Self {
        UnitPicopoises
    }
}
impl Add<UnitPicopoises> for UnitPicopoises {
    type Output = UnitPicopoises;
    #[inline]
    fn add(self, _: UnitPicopoises) -> Self::Output {
        UnitPicopoises
    }
}
impl AddAssign<UnitPicopoises> for UnitPicopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitPicopoises) {}
}
impl Sub<UnitPicopoises> for UnitPicopoises {
    type Output = UnitPicopoises;
    #[inline]
    fn sub(self, _: UnitPicopoises) -> Self::Output {
        UnitPicopoises
    }
}
impl SubAssign<UnitPicopoises> for UnitPicopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicopoises) {}
}
pub struct UnitPicopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicopoisesMul {
    #[inline]
    fn clone(&self) -> UnitPicopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitPicopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicopoisesMul> for i8 {
    type Output = Quantity<i8, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for i16 {
    type Output = Quantity<i16, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for i32 {
    type Output = Quantity<i32, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for i64 {
    type Output = Quantity<i64, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for i128 {
    type Output = Quantity<i128, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for isize {
    type Output = Quantity<isize, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for u8 {
    type Output = Quantity<u8, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for u16 {
    type Output = Quantity<u16, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for u32 {
    type Output = Quantity<u32, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for u64 {
    type Output = Quantity<u64, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for u128 {
    type Output = Quantity<u128, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for usize {
    type Output = Quantity<usize, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for f32 {
    type Output = Quantity<f32, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
impl Mul<UnitPicopoisesMul> for f64 {
    type Output = Quantity<f64, UnitPicopoises>;
    fn mul(self, _: UnitPicopoisesMul) -> Self::Output {
        Quantity::new(self, UnitPicopoises)
    }
}
pub struct UnitFemtopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtopoises {
    #[inline]
    fn clone(&self) -> UnitFemtopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtopoises {
    #[inline]
    fn eq(&self, other: &UnitFemtopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtopoises {
    fn default() -> Self {
        UnitFemtopoises
    }
}
impl Add<UnitFemtopoises> for UnitFemtopoises {
    type Output = UnitFemtopoises;
    #[inline]
    fn add(self, _: UnitFemtopoises) -> Self::Output {
        UnitFemtopoises
    }
}
impl AddAssign<UnitFemtopoises> for UnitFemtopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtopoises) {}
}
impl Sub<UnitFemtopoises> for UnitFemtopoises {
    type Output = UnitFemtopoises;
    #[inline]
    fn sub(self, _: UnitFemtopoises) -> Self::Output {
        UnitFemtopoises
    }
}
impl SubAssign<UnitFemtopoises> for UnitFemtopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtopoises) {}
}
pub struct UnitFemtopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtopoisesMul {
    #[inline]
    fn clone(&self) -> UnitFemtopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtopoisesMul> for i8 {
    type Output = Quantity<i8, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for i16 {
    type Output = Quantity<i16, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for i32 {
    type Output = Quantity<i32, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for i64 {
    type Output = Quantity<i64, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for i128 {
    type Output = Quantity<i128, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for isize {
    type Output = Quantity<isize, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for u8 {
    type Output = Quantity<u8, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for u16 {
    type Output = Quantity<u16, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for u32 {
    type Output = Quantity<u32, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for u64 {
    type Output = Quantity<u64, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for u128 {
    type Output = Quantity<u128, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for usize {
    type Output = Quantity<usize, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for f32 {
    type Output = Quantity<f32, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
impl Mul<UnitFemtopoisesMul> for f64 {
    type Output = Quantity<f64, UnitFemtopoises>;
    fn mul(self, _: UnitFemtopoisesMul) -> Self::Output {
        Quantity::new(self, UnitFemtopoises)
    }
}
pub struct UnitAttopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttopoises {
    #[inline]
    fn clone(&self) -> UnitAttopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttopoises {
    #[inline]
    fn eq(&self, other: &UnitAttopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttopoises {
    fn default() -> Self {
        UnitAttopoises
    }
}
impl Add<UnitAttopoises> for UnitAttopoises {
    type Output = UnitAttopoises;
    #[inline]
    fn add(self, _: UnitAttopoises) -> Self::Output {
        UnitAttopoises
    }
}
impl AddAssign<UnitAttopoises> for UnitAttopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitAttopoises) {}
}
impl Sub<UnitAttopoises> for UnitAttopoises {
    type Output = UnitAttopoises;
    #[inline]
    fn sub(self, _: UnitAttopoises) -> Self::Output {
        UnitAttopoises
    }
}
impl SubAssign<UnitAttopoises> for UnitAttopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttopoises) {}
}
pub struct UnitAttopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttopoisesMul {
    #[inline]
    fn clone(&self) -> UnitAttopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitAttopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttopoisesMul> for i8 {
    type Output = Quantity<i8, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for i16 {
    type Output = Quantity<i16, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for i32 {
    type Output = Quantity<i32, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for i64 {
    type Output = Quantity<i64, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for i128 {
    type Output = Quantity<i128, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for isize {
    type Output = Quantity<isize, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for u8 {
    type Output = Quantity<u8, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for u16 {
    type Output = Quantity<u16, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for u32 {
    type Output = Quantity<u32, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for u64 {
    type Output = Quantity<u64, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for u128 {
    type Output = Quantity<u128, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for usize {
    type Output = Quantity<usize, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for f32 {
    type Output = Quantity<f32, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
impl Mul<UnitAttopoisesMul> for f64 {
    type Output = Quantity<f64, UnitAttopoises>;
    fn mul(self, _: UnitAttopoisesMul) -> Self::Output {
        Quantity::new(self, UnitAttopoises)
    }
}
pub struct UnitZeptopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptopoises {
    #[inline]
    fn clone(&self) -> UnitZeptopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptopoises {
    #[inline]
    fn eq(&self, other: &UnitZeptopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptopoises {
    fn default() -> Self {
        UnitZeptopoises
    }
}
impl Add<UnitZeptopoises> for UnitZeptopoises {
    type Output = UnitZeptopoises;
    #[inline]
    fn add(self, _: UnitZeptopoises) -> Self::Output {
        UnitZeptopoises
    }
}
impl AddAssign<UnitZeptopoises> for UnitZeptopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptopoises) {}
}
impl Sub<UnitZeptopoises> for UnitZeptopoises {
    type Output = UnitZeptopoises;
    #[inline]
    fn sub(self, _: UnitZeptopoises) -> Self::Output {
        UnitZeptopoises
    }
}
impl SubAssign<UnitZeptopoises> for UnitZeptopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptopoises) {}
}
pub struct UnitZeptopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptopoisesMul {
    #[inline]
    fn clone(&self) -> UnitZeptopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptopoisesMul> for i8 {
    type Output = Quantity<i8, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for i16 {
    type Output = Quantity<i16, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for i32 {
    type Output = Quantity<i32, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for i64 {
    type Output = Quantity<i64, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for i128 {
    type Output = Quantity<i128, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for isize {
    type Output = Quantity<isize, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for u8 {
    type Output = Quantity<u8, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for u16 {
    type Output = Quantity<u16, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for u32 {
    type Output = Quantity<u32, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for u64 {
    type Output = Quantity<u64, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for u128 {
    type Output = Quantity<u128, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for usize {
    type Output = Quantity<usize, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for f32 {
    type Output = Quantity<f32, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
impl Mul<UnitZeptopoisesMul> for f64 {
    type Output = Quantity<f64, UnitZeptopoises>;
    fn mul(self, _: UnitZeptopoisesMul) -> Self::Output {
        Quantity::new(self, UnitZeptopoises)
    }
}
pub struct UnitYoctopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctopoises {
    #[inline]
    fn clone(&self) -> UnitYoctopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctopoises {
    #[inline]
    fn eq(&self, other: &UnitYoctopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctopoises {
    fn default() -> Self {
        UnitYoctopoises
    }
}
impl Add<UnitYoctopoises> for UnitYoctopoises {
    type Output = UnitYoctopoises;
    #[inline]
    fn add(self, _: UnitYoctopoises) -> Self::Output {
        UnitYoctopoises
    }
}
impl AddAssign<UnitYoctopoises> for UnitYoctopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctopoises) {}
}
impl Sub<UnitYoctopoises> for UnitYoctopoises {
    type Output = UnitYoctopoises;
    #[inline]
    fn sub(self, _: UnitYoctopoises) -> Self::Output {
        UnitYoctopoises
    }
}
impl SubAssign<UnitYoctopoises> for UnitYoctopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctopoises) {}
}
pub struct UnitYoctopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctopoisesMul {
    #[inline]
    fn clone(&self) -> UnitYoctopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctopoisesMul> for i8 {
    type Output = Quantity<i8, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for i16 {
    type Output = Quantity<i16, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for i32 {
    type Output = Quantity<i32, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for i64 {
    type Output = Quantity<i64, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for i128 {
    type Output = Quantity<i128, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for isize {
    type Output = Quantity<isize, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for u8 {
    type Output = Quantity<u8, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for u16 {
    type Output = Quantity<u16, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for u32 {
    type Output = Quantity<u32, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for u64 {
    type Output = Quantity<u64, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for u128 {
    type Output = Quantity<u128, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for usize {
    type Output = Quantity<usize, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for f32 {
    type Output = Quantity<f32, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
impl Mul<UnitYoctopoisesMul> for f64 {
    type Output = Quantity<f64, UnitYoctopoises>;
    fn mul(self, _: UnitYoctopoisesMul) -> Self::Output {
        Quantity::new(self, UnitYoctopoises)
    }
}
pub struct UnitRontopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontopoises {
    #[inline]
    fn clone(&self) -> UnitRontopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontopoises {
    #[inline]
    fn eq(&self, other: &UnitRontopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontopoises {
    fn default() -> Self {
        UnitRontopoises
    }
}
impl Add<UnitRontopoises> for UnitRontopoises {
    type Output = UnitRontopoises;
    #[inline]
    fn add(self, _: UnitRontopoises) -> Self::Output {
        UnitRontopoises
    }
}
impl AddAssign<UnitRontopoises> for UnitRontopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitRontopoises) {}
}
impl Sub<UnitRontopoises> for UnitRontopoises {
    type Output = UnitRontopoises;
    #[inline]
    fn sub(self, _: UnitRontopoises) -> Self::Output {
        UnitRontopoises
    }
}
impl SubAssign<UnitRontopoises> for UnitRontopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontopoises) {}
}
pub struct UnitRontopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontopoisesMul {
    #[inline]
    fn clone(&self) -> UnitRontopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitRontopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontopoisesMul> for i8 {
    type Output = Quantity<i8, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for i16 {
    type Output = Quantity<i16, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for i32 {
    type Output = Quantity<i32, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for i64 {
    type Output = Quantity<i64, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for i128 {
    type Output = Quantity<i128, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for isize {
    type Output = Quantity<isize, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for u8 {
    type Output = Quantity<u8, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for u16 {
    type Output = Quantity<u16, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for u32 {
    type Output = Quantity<u32, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for u64 {
    type Output = Quantity<u64, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for u128 {
    type Output = Quantity<u128, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for usize {
    type Output = Quantity<usize, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for f32 {
    type Output = Quantity<f32, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
impl Mul<UnitRontopoisesMul> for f64 {
    type Output = Quantity<f64, UnitRontopoises>;
    fn mul(self, _: UnitRontopoisesMul) -> Self::Output {
        Quantity::new(self, UnitRontopoises)
    }
}
pub struct UnitQuectopoises;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectopoises {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectopoises")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectopoises {
    #[inline]
    fn clone(&self) -> UnitQuectopoises {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectopoises {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectopoises {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectopoises {
    #[inline]
    fn eq(&self, other: &UnitQuectopoises) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectopoises {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectopoises {
    fn default() -> Self {
        UnitQuectopoises
    }
}
impl Add<UnitQuectopoises> for UnitQuectopoises {
    type Output = UnitQuectopoises;
    #[inline]
    fn add(self, _: UnitQuectopoises) -> Self::Output {
        UnitQuectopoises
    }
}
impl AddAssign<UnitQuectopoises> for UnitQuectopoises {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectopoises) {}
}
impl Sub<UnitQuectopoises> for UnitQuectopoises {
    type Output = UnitQuectopoises;
    #[inline]
    fn sub(self, _: UnitQuectopoises) -> Self::Output {
        UnitQuectopoises
    }
}
impl SubAssign<UnitQuectopoises> for UnitQuectopoises {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectopoises) {}
}
pub struct UnitQuectopoisesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectopoisesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectopoisesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectopoisesMul {
    #[inline]
    fn clone(&self) -> UnitQuectopoisesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectopoisesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectopoisesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectopoisesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectopoisesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectopoisesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectopoisesMul> for i8 {
    type Output = Quantity<i8, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for i16 {
    type Output = Quantity<i16, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for i32 {
    type Output = Quantity<i32, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for i64 {
    type Output = Quantity<i64, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for i128 {
    type Output = Quantity<i128, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for isize {
    type Output = Quantity<isize, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for u8 {
    type Output = Quantity<u8, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for u16 {
    type Output = Quantity<u16, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for u32 {
    type Output = Quantity<u32, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for u64 {
    type Output = Quantity<u64, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for u128 {
    type Output = Quantity<u128, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for usize {
    type Output = Quantity<usize, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for f32 {
    type Output = Quantity<f32, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
impl Mul<UnitQuectopoisesMul> for f64 {
    type Output = Quantity<f64, UnitQuectopoises>;
    fn mul(self, _: UnitQuectopoisesMul) -> Self::Output {
        Quantity::new(self, UnitQuectopoises)
    }
}
pub type Poises<T> = Quantity<T, UnitPoises>;
#[allow(non_upper_case_globals)]
pub static Poises: UnitPoisesMul = UnitPoisesMul;
pub type Quettapoises<T> = Quantity<T, UnitQuettapoises>;
#[allow(non_upper_case_globals)]
pub static Quettapoises: UnitQuettapoisesMul = UnitQuettapoisesMul;
pub type Ronnapoises<T> = Quantity<T, UnitRonnapoises>;
#[allow(non_upper_case_globals)]
pub static Ronnapoises: UnitRonnapoisesMul = UnitRonnapoisesMul;
pub type Yottapoises<T> = Quantity<T, UnitYottapoises>;
#[allow(non_upper_case_globals)]
pub static Yottapoises: UnitYottapoisesMul = UnitYottapoisesMul;
pub type Zettapoises<T> = Quantity<T, UnitZettapoises>;
#[allow(non_upper_case_globals)]
pub static Zettapoises: UnitZettapoisesMul = UnitZettapoisesMul;
pub type Exapoises<T> = Quantity<T, UnitExapoises>;
#[allow(non_upper_case_globals)]
pub static Exapoises: UnitExapoisesMul = UnitExapoisesMul;
pub type Petapoises<T> = Quantity<T, UnitPetapoises>;
#[allow(non_upper_case_globals)]
pub static Petapoises: UnitPetapoisesMul = UnitPetapoisesMul;
pub type Terapoises<T> = Quantity<T, UnitTerapoises>;
#[allow(non_upper_case_globals)]
pub static Terapoises: UnitTerapoisesMul = UnitTerapoisesMul;
pub type Gigapoises<T> = Quantity<T, UnitGigapoises>;
#[allow(non_upper_case_globals)]
pub static Gigapoises: UnitGigapoisesMul = UnitGigapoisesMul;
pub type Megapoises<T> = Quantity<T, UnitMegapoises>;
#[allow(non_upper_case_globals)]
pub static Megapoises: UnitMegapoisesMul = UnitMegapoisesMul;
pub type Kilopoises<T> = Quantity<T, UnitKilopoises>;
#[allow(non_upper_case_globals)]
pub static Kilopoises: UnitKilopoisesMul = UnitKilopoisesMul;
pub type Hectopoises<T> = Quantity<T, UnitHectopoises>;
#[allow(non_upper_case_globals)]
pub static Hectopoises: UnitHectopoisesMul = UnitHectopoisesMul;
pub type Decapoises<T> = Quantity<T, UnitDecapoises>;
#[allow(non_upper_case_globals)]
pub static Decapoises: UnitDecapoisesMul = UnitDecapoisesMul;
pub type Decipoises<T> = Quantity<T, UnitDecipoises>;
#[allow(non_upper_case_globals)]
pub static Decipoises: UnitDecipoisesMul = UnitDecipoisesMul;
pub type Centipoises<T> = Quantity<T, UnitCentipoises>;
#[allow(non_upper_case_globals)]
pub static Centipoises: UnitCentipoisesMul = UnitCentipoisesMul;
pub type Millipoises<T> = Quantity<T, UnitMillipoises>;
#[allow(non_upper_case_globals)]
pub static Millipoises: UnitMillipoisesMul = UnitMillipoisesMul;
pub type Micropoises<T> = Quantity<T, UnitMicropoises>;
#[allow(non_upper_case_globals)]
pub static Micropoises: UnitMicropoisesMul = UnitMicropoisesMul;
pub type Nanopoises<T> = Quantity<T, UnitNanopoises>;
#[allow(non_upper_case_globals)]
pub static Nanopoises: UnitNanopoisesMul = UnitNanopoisesMul;
pub type Picopoises<T> = Quantity<T, UnitPicopoises>;
#[allow(non_upper_case_globals)]
pub static Picopoises: UnitPicopoisesMul = UnitPicopoisesMul;
pub type Femtopoises<T> = Quantity<T, UnitFemtopoises>;
#[allow(non_upper_case_globals)]
pub static Femtopoises: UnitFemtopoisesMul = UnitFemtopoisesMul;
pub type Attopoises<T> = Quantity<T, UnitAttopoises>;
#[allow(non_upper_case_globals)]
pub static Attopoises: UnitAttopoisesMul = UnitAttopoisesMul;
pub type Zeptopoises<T> = Quantity<T, UnitZeptopoises>;
#[allow(non_upper_case_globals)]
pub static Zeptopoises: UnitZeptopoisesMul = UnitZeptopoisesMul;
pub type Yoctopoises<T> = Quantity<T, UnitYoctopoises>;
#[allow(non_upper_case_globals)]
pub static Yoctopoises: UnitYoctopoisesMul = UnitYoctopoisesMul;
pub type Rontopoises<T> = Quantity<T, UnitRontopoises>;
#[allow(non_upper_case_globals)]
pub static Rontopoises: UnitRontopoisesMul = UnitRontopoisesMul;
pub type Quectopoises<T> = Quantity<T, UnitQuectopoises>;
#[allow(non_upper_case_globals)]
pub static Quectopoises: UnitQuectopoisesMul = UnitQuectopoisesMul;
pub struct UnitStokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitStokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitStokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitStokes {
    #[inline]
    fn clone(&self) -> UnitStokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitStokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitStokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitStokes {
    #[inline]
    fn eq(&self, other: &UnitStokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitStokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitStokes {
    fn default() -> Self {
        UnitStokes
    }
}
impl Add<UnitStokes> for UnitStokes {
    type Output = UnitStokes;
    #[inline]
    fn add(self, _: UnitStokes) -> Self::Output {
        UnitStokes
    }
}
impl AddAssign<UnitStokes> for UnitStokes {
    #[inline]
    fn add_assign(&mut self, _: UnitStokes) {}
}
impl Sub<UnitStokes> for UnitStokes {
    type Output = UnitStokes;
    #[inline]
    fn sub(self, _: UnitStokes) -> Self::Output {
        UnitStokes
    }
}
impl SubAssign<UnitStokes> for UnitStokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitStokes) {}
}
pub struct UnitStokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitStokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitStokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitStokesMul {
    #[inline]
    fn clone(&self) -> UnitStokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitStokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitStokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitStokesMul {
    #[inline]
    fn eq(&self, other: &UnitStokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitStokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitStokesMul> for i8 {
    type Output = Quantity<i8, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for i16 {
    type Output = Quantity<i16, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for i32 {
    type Output = Quantity<i32, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for i64 {
    type Output = Quantity<i64, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for i128 {
    type Output = Quantity<i128, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for isize {
    type Output = Quantity<isize, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for u8 {
    type Output = Quantity<u8, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for u16 {
    type Output = Quantity<u16, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for u32 {
    type Output = Quantity<u32, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for u64 {
    type Output = Quantity<u64, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for u128 {
    type Output = Quantity<u128, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for usize {
    type Output = Quantity<usize, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for f32 {
    type Output = Quantity<f32, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
impl Mul<UnitStokesMul> for f64 {
    type Output = Quantity<f64, UnitStokes>;
    fn mul(self, _: UnitStokesMul) -> Self::Output {
        Quantity::new(self, UnitStokes)
    }
}
pub struct UnitQuettastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettastokes {
    #[inline]
    fn clone(&self) -> UnitQuettastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettastokes {
    #[inline]
    fn eq(&self, other: &UnitQuettastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettastokes {
    fn default() -> Self {
        UnitQuettastokes
    }
}
impl Add<UnitQuettastokes> for UnitQuettastokes {
    type Output = UnitQuettastokes;
    #[inline]
    fn add(self, _: UnitQuettastokes) -> Self::Output {
        UnitQuettastokes
    }
}
impl AddAssign<UnitQuettastokes> for UnitQuettastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettastokes) {}
}
impl Sub<UnitQuettastokes> for UnitQuettastokes {
    type Output = UnitQuettastokes;
    #[inline]
    fn sub(self, _: UnitQuettastokes) -> Self::Output {
        UnitQuettastokes
    }
}
impl SubAssign<UnitQuettastokes> for UnitQuettastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettastokes) {}
}
pub struct UnitQuettastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettastokesMul {
    #[inline]
    fn clone(&self) -> UnitQuettastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettastokesMul {
    #[inline]
    fn eq(&self, other: &UnitQuettastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettastokesMul> for i8 {
    type Output = Quantity<i8, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for i16 {
    type Output = Quantity<i16, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for i32 {
    type Output = Quantity<i32, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for i64 {
    type Output = Quantity<i64, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for i128 {
    type Output = Quantity<i128, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for isize {
    type Output = Quantity<isize, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for u8 {
    type Output = Quantity<u8, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for u16 {
    type Output = Quantity<u16, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for u32 {
    type Output = Quantity<u32, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for u64 {
    type Output = Quantity<u64, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for u128 {
    type Output = Quantity<u128, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for usize {
    type Output = Quantity<usize, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for f32 {
    type Output = Quantity<f32, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
impl Mul<UnitQuettastokesMul> for f64 {
    type Output = Quantity<f64, UnitQuettastokes>;
    fn mul(self, _: UnitQuettastokesMul) -> Self::Output {
        Quantity::new(self, UnitQuettastokes)
    }
}
pub struct UnitRonnastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnastokes {
    #[inline]
    fn clone(&self) -> UnitRonnastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnastokes {
    #[inline]
    fn eq(&self, other: &UnitRonnastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnastokes {
    fn default() -> Self {
        UnitRonnastokes
    }
}
impl Add<UnitRonnastokes> for UnitRonnastokes {
    type Output = UnitRonnastokes;
    #[inline]
    fn add(self, _: UnitRonnastokes) -> Self::Output {
        UnitRonnastokes
    }
}
impl AddAssign<UnitRonnastokes> for UnitRonnastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnastokes) {}
}
impl Sub<UnitRonnastokes> for UnitRonnastokes {
    type Output = UnitRonnastokes;
    #[inline]
    fn sub(self, _: UnitRonnastokes) -> Self::Output {
        UnitRonnastokes
    }
}
impl SubAssign<UnitRonnastokes> for UnitRonnastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnastokes) {}
}
pub struct UnitRonnastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnastokesMul {
    #[inline]
    fn clone(&self) -> UnitRonnastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnastokesMul {
    #[inline]
    fn eq(&self, other: &UnitRonnastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnastokesMul> for i8 {
    type Output = Quantity<i8, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for i16 {
    type Output = Quantity<i16, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for i32 {
    type Output = Quantity<i32, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for i64 {
    type Output = Quantity<i64, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for i128 {
    type Output = Quantity<i128, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for isize {
    type Output = Quantity<isize, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for u8 {
    type Output = Quantity<u8, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for u16 {
    type Output = Quantity<u16, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for u32 {
    type Output = Quantity<u32, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for u64 {
    type Output = Quantity<u64, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for u128 {
    type Output = Quantity<u128, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for usize {
    type Output = Quantity<usize, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for f32 {
    type Output = Quantity<f32, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
impl Mul<UnitRonnastokesMul> for f64 {
    type Output = Quantity<f64, UnitRonnastokes>;
    fn mul(self, _: UnitRonnastokesMul) -> Self::Output {
        Quantity::new(self, UnitRonnastokes)
    }
}
pub struct UnitYottastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottastokes {
    #[inline]
    fn clone(&self) -> UnitYottastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottastokes {
    #[inline]
    fn eq(&self, other: &UnitYottastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottastokes {
    fn default() -> Self {
        UnitYottastokes
    }
}
impl Add<UnitYottastokes> for UnitYottastokes {
    type Output = UnitYottastokes;
    #[inline]
    fn add(self, _: UnitYottastokes) -> Self::Output {
        UnitYottastokes
    }
}
impl AddAssign<UnitYottastokes> for UnitYottastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitYottastokes) {}
}
impl Sub<UnitYottastokes> for UnitYottastokes {
    type Output = UnitYottastokes;
    #[inline]
    fn sub(self, _: UnitYottastokes) -> Self::Output {
        UnitYottastokes
    }
}
impl SubAssign<UnitYottastokes> for UnitYottastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottastokes) {}
}
pub struct UnitYottastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottastokesMul {
    #[inline]
    fn clone(&self) -> UnitYottastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottastokesMul {
    #[inline]
    fn eq(&self, other: &UnitYottastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottastokesMul> for i8 {
    type Output = Quantity<i8, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for i16 {
    type Output = Quantity<i16, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for i32 {
    type Output = Quantity<i32, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for i64 {
    type Output = Quantity<i64, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for i128 {
    type Output = Quantity<i128, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for isize {
    type Output = Quantity<isize, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for u8 {
    type Output = Quantity<u8, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for u16 {
    type Output = Quantity<u16, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for u32 {
    type Output = Quantity<u32, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for u64 {
    type Output = Quantity<u64, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for u128 {
    type Output = Quantity<u128, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for usize {
    type Output = Quantity<usize, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for f32 {
    type Output = Quantity<f32, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
impl Mul<UnitYottastokesMul> for f64 {
    type Output = Quantity<f64, UnitYottastokes>;
    fn mul(self, _: UnitYottastokesMul) -> Self::Output {
        Quantity::new(self, UnitYottastokes)
    }
}
pub struct UnitZettastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettastokes {
    #[inline]
    fn clone(&self) -> UnitZettastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettastokes {
    #[inline]
    fn eq(&self, other: &UnitZettastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettastokes {
    fn default() -> Self {
        UnitZettastokes
    }
}
impl Add<UnitZettastokes> for UnitZettastokes {
    type Output = UnitZettastokes;
    #[inline]
    fn add(self, _: UnitZettastokes) -> Self::Output {
        UnitZettastokes
    }
}
impl AddAssign<UnitZettastokes> for UnitZettastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitZettastokes) {}
}
impl Sub<UnitZettastokes> for UnitZettastokes {
    type Output = UnitZettastokes;
    #[inline]
    fn sub(self, _: UnitZettastokes) -> Self::Output {
        UnitZettastokes
    }
}
impl SubAssign<UnitZettastokes> for UnitZettastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettastokes) {}
}
pub struct UnitZettastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettastokesMul {
    #[inline]
    fn clone(&self) -> UnitZettastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettastokesMul {
    #[inline]
    fn eq(&self, other: &UnitZettastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettastokesMul> for i8 {
    type Output = Quantity<i8, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for i16 {
    type Output = Quantity<i16, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for i32 {
    type Output = Quantity<i32, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for i64 {
    type Output = Quantity<i64, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for i128 {
    type Output = Quantity<i128, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for isize {
    type Output = Quantity<isize, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for u8 {
    type Output = Quantity<u8, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for u16 {
    type Output = Quantity<u16, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for u32 {
    type Output = Quantity<u32, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for u64 {
    type Output = Quantity<u64, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for u128 {
    type Output = Quantity<u128, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for usize {
    type Output = Quantity<usize, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for f32 {
    type Output = Quantity<f32, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
impl Mul<UnitZettastokesMul> for f64 {
    type Output = Quantity<f64, UnitZettastokes>;
    fn mul(self, _: UnitZettastokesMul) -> Self::Output {
        Quantity::new(self, UnitZettastokes)
    }
}
pub struct UnitExastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExastokes {
    #[inline]
    fn clone(&self) -> UnitExastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExastokes {
    #[inline]
    fn eq(&self, other: &UnitExastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExastokes {
    fn default() -> Self {
        UnitExastokes
    }
}
impl Add<UnitExastokes> for UnitExastokes {
    type Output = UnitExastokes;
    #[inline]
    fn add(self, _: UnitExastokes) -> Self::Output {
        UnitExastokes
    }
}
impl AddAssign<UnitExastokes> for UnitExastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitExastokes) {}
}
impl Sub<UnitExastokes> for UnitExastokes {
    type Output = UnitExastokes;
    #[inline]
    fn sub(self, _: UnitExastokes) -> Self::Output {
        UnitExastokes
    }
}
impl SubAssign<UnitExastokes> for UnitExastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitExastokes) {}
}
pub struct UnitExastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExastokesMul {
    #[inline]
    fn clone(&self) -> UnitExastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExastokesMul {
    #[inline]
    fn eq(&self, other: &UnitExastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExastokesMul> for i8 {
    type Output = Quantity<i8, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for i16 {
    type Output = Quantity<i16, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for i32 {
    type Output = Quantity<i32, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for i64 {
    type Output = Quantity<i64, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for i128 {
    type Output = Quantity<i128, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for isize {
    type Output = Quantity<isize, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for u8 {
    type Output = Quantity<u8, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for u16 {
    type Output = Quantity<u16, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for u32 {
    type Output = Quantity<u32, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for u64 {
    type Output = Quantity<u64, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for u128 {
    type Output = Quantity<u128, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for usize {
    type Output = Quantity<usize, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for f32 {
    type Output = Quantity<f32, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
impl Mul<UnitExastokesMul> for f64 {
    type Output = Quantity<f64, UnitExastokes>;
    fn mul(self, _: UnitExastokesMul) -> Self::Output {
        Quantity::new(self, UnitExastokes)
    }
}
pub struct UnitPetastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetastokes {
    #[inline]
    fn clone(&self) -> UnitPetastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetastokes {
    #[inline]
    fn eq(&self, other: &UnitPetastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetastokes {
    fn default() -> Self {
        UnitPetastokes
    }
}
impl Add<UnitPetastokes> for UnitPetastokes {
    type Output = UnitPetastokes;
    #[inline]
    fn add(self, _: UnitPetastokes) -> Self::Output {
        UnitPetastokes
    }
}
impl AddAssign<UnitPetastokes> for UnitPetastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitPetastokes) {}
}
impl Sub<UnitPetastokes> for UnitPetastokes {
    type Output = UnitPetastokes;
    #[inline]
    fn sub(self, _: UnitPetastokes) -> Self::Output {
        UnitPetastokes
    }
}
impl SubAssign<UnitPetastokes> for UnitPetastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetastokes) {}
}
pub struct UnitPetastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetastokesMul {
    #[inline]
    fn clone(&self) -> UnitPetastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetastokesMul {
    #[inline]
    fn eq(&self, other: &UnitPetastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetastokesMul> for i8 {
    type Output = Quantity<i8, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for i16 {
    type Output = Quantity<i16, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for i32 {
    type Output = Quantity<i32, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for i64 {
    type Output = Quantity<i64, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for i128 {
    type Output = Quantity<i128, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for isize {
    type Output = Quantity<isize, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for u8 {
    type Output = Quantity<u8, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for u16 {
    type Output = Quantity<u16, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for u32 {
    type Output = Quantity<u32, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for u64 {
    type Output = Quantity<u64, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for u128 {
    type Output = Quantity<u128, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for usize {
    type Output = Quantity<usize, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for f32 {
    type Output = Quantity<f32, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
impl Mul<UnitPetastokesMul> for f64 {
    type Output = Quantity<f64, UnitPetastokes>;
    fn mul(self, _: UnitPetastokesMul) -> Self::Output {
        Quantity::new(self, UnitPetastokes)
    }
}
pub struct UnitTerastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerastokes {
    #[inline]
    fn clone(&self) -> UnitTerastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerastokes {
    #[inline]
    fn eq(&self, other: &UnitTerastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerastokes {
    fn default() -> Self {
        UnitTerastokes
    }
}
impl Add<UnitTerastokes> for UnitTerastokes {
    type Output = UnitTerastokes;
    #[inline]
    fn add(self, _: UnitTerastokes) -> Self::Output {
        UnitTerastokes
    }
}
impl AddAssign<UnitTerastokes> for UnitTerastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitTerastokes) {}
}
impl Sub<UnitTerastokes> for UnitTerastokes {
    type Output = UnitTerastokes;
    #[inline]
    fn sub(self, _: UnitTerastokes) -> Self::Output {
        UnitTerastokes
    }
}
impl SubAssign<UnitTerastokes> for UnitTerastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerastokes) {}
}
pub struct UnitTerastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerastokesMul {
    #[inline]
    fn clone(&self) -> UnitTerastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerastokesMul {
    #[inline]
    fn eq(&self, other: &UnitTerastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerastokesMul> for i8 {
    type Output = Quantity<i8, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for i16 {
    type Output = Quantity<i16, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for i32 {
    type Output = Quantity<i32, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for i64 {
    type Output = Quantity<i64, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for i128 {
    type Output = Quantity<i128, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for isize {
    type Output = Quantity<isize, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for u8 {
    type Output = Quantity<u8, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for u16 {
    type Output = Quantity<u16, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for u32 {
    type Output = Quantity<u32, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for u64 {
    type Output = Quantity<u64, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for u128 {
    type Output = Quantity<u128, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for usize {
    type Output = Quantity<usize, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for f32 {
    type Output = Quantity<f32, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
impl Mul<UnitTerastokesMul> for f64 {
    type Output = Quantity<f64, UnitTerastokes>;
    fn mul(self, _: UnitTerastokesMul) -> Self::Output {
        Quantity::new(self, UnitTerastokes)
    }
}
pub struct UnitGigastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigastokes {
    #[inline]
    fn clone(&self) -> UnitGigastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigastokes {
    #[inline]
    fn eq(&self, other: &UnitGigastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigastokes {
    fn default() -> Self {
        UnitGigastokes
    }
}
impl Add<UnitGigastokes> for UnitGigastokes {
    type Output = UnitGigastokes;
    #[inline]
    fn add(self, _: UnitGigastokes) -> Self::Output {
        UnitGigastokes
    }
}
impl AddAssign<UnitGigastokes> for UnitGigastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitGigastokes) {}
}
impl Sub<UnitGigastokes> for UnitGigastokes {
    type Output = UnitGigastokes;
    #[inline]
    fn sub(self, _: UnitGigastokes) -> Self::Output {
        UnitGigastokes
    }
}
impl SubAssign<UnitGigastokes> for UnitGigastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigastokes) {}
}
pub struct UnitGigastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigastokesMul {
    #[inline]
    fn clone(&self) -> UnitGigastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigastokesMul {
    #[inline]
    fn eq(&self, other: &UnitGigastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigastokesMul> for i8 {
    type Output = Quantity<i8, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for i16 {
    type Output = Quantity<i16, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for i32 {
    type Output = Quantity<i32, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for i64 {
    type Output = Quantity<i64, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for i128 {
    type Output = Quantity<i128, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for isize {
    type Output = Quantity<isize, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for u8 {
    type Output = Quantity<u8, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for u16 {
    type Output = Quantity<u16, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for u32 {
    type Output = Quantity<u32, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for u64 {
    type Output = Quantity<u64, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for u128 {
    type Output = Quantity<u128, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for usize {
    type Output = Quantity<usize, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for f32 {
    type Output = Quantity<f32, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
impl Mul<UnitGigastokesMul> for f64 {
    type Output = Quantity<f64, UnitGigastokes>;
    fn mul(self, _: UnitGigastokesMul) -> Self::Output {
        Quantity::new(self, UnitGigastokes)
    }
}
pub struct UnitMegastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegastokes {
    #[inline]
    fn clone(&self) -> UnitMegastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegastokes {
    #[inline]
    fn eq(&self, other: &UnitMegastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegastokes {
    fn default() -> Self {
        UnitMegastokes
    }
}
impl Add<UnitMegastokes> for UnitMegastokes {
    type Output = UnitMegastokes;
    #[inline]
    fn add(self, _: UnitMegastokes) -> Self::Output {
        UnitMegastokes
    }
}
impl AddAssign<UnitMegastokes> for UnitMegastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitMegastokes) {}
}
impl Sub<UnitMegastokes> for UnitMegastokes {
    type Output = UnitMegastokes;
    #[inline]
    fn sub(self, _: UnitMegastokes) -> Self::Output {
        UnitMegastokes
    }
}
impl SubAssign<UnitMegastokes> for UnitMegastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegastokes) {}
}
pub struct UnitMegastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegastokesMul {
    #[inline]
    fn clone(&self) -> UnitMegastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegastokesMul {
    #[inline]
    fn eq(&self, other: &UnitMegastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegastokesMul> for i8 {
    type Output = Quantity<i8, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for i16 {
    type Output = Quantity<i16, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for i32 {
    type Output = Quantity<i32, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for i64 {
    type Output = Quantity<i64, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for i128 {
    type Output = Quantity<i128, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for isize {
    type Output = Quantity<isize, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for u8 {
    type Output = Quantity<u8, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for u16 {
    type Output = Quantity<u16, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for u32 {
    type Output = Quantity<u32, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for u64 {
    type Output = Quantity<u64, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for u128 {
    type Output = Quantity<u128, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for usize {
    type Output = Quantity<usize, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for f32 {
    type Output = Quantity<f32, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
impl Mul<UnitMegastokesMul> for f64 {
    type Output = Quantity<f64, UnitMegastokes>;
    fn mul(self, _: UnitMegastokesMul) -> Self::Output {
        Quantity::new(self, UnitMegastokes)
    }
}
pub struct UnitKilostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilostokes {
    #[inline]
    fn clone(&self) -> UnitKilostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilostokes {
    #[inline]
    fn eq(&self, other: &UnitKilostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilostokes {
    fn default() -> Self {
        UnitKilostokes
    }
}
impl Add<UnitKilostokes> for UnitKilostokes {
    type Output = UnitKilostokes;
    #[inline]
    fn add(self, _: UnitKilostokes) -> Self::Output {
        UnitKilostokes
    }
}
impl AddAssign<UnitKilostokes> for UnitKilostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitKilostokes) {}
}
impl Sub<UnitKilostokes> for UnitKilostokes {
    type Output = UnitKilostokes;
    #[inline]
    fn sub(self, _: UnitKilostokes) -> Self::Output {
        UnitKilostokes
    }
}
impl SubAssign<UnitKilostokes> for UnitKilostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilostokes) {}
}
pub struct UnitKilostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilostokesMul {
    #[inline]
    fn clone(&self) -> UnitKilostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilostokesMul {
    #[inline]
    fn eq(&self, other: &UnitKilostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilostokesMul> for i8 {
    type Output = Quantity<i8, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for i16 {
    type Output = Quantity<i16, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for i32 {
    type Output = Quantity<i32, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for i64 {
    type Output = Quantity<i64, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for i128 {
    type Output = Quantity<i128, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for isize {
    type Output = Quantity<isize, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for u8 {
    type Output = Quantity<u8, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for u16 {
    type Output = Quantity<u16, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for u32 {
    type Output = Quantity<u32, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for u64 {
    type Output = Quantity<u64, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for u128 {
    type Output = Quantity<u128, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for usize {
    type Output = Quantity<usize, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for f32 {
    type Output = Quantity<f32, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
impl Mul<UnitKilostokesMul> for f64 {
    type Output = Quantity<f64, UnitKilostokes>;
    fn mul(self, _: UnitKilostokesMul) -> Self::Output {
        Quantity::new(self, UnitKilostokes)
    }
}
pub struct UnitHectostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectostokes {
    #[inline]
    fn clone(&self) -> UnitHectostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectostokes {
    #[inline]
    fn eq(&self, other: &UnitHectostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectostokes {
    fn default() -> Self {
        UnitHectostokes
    }
}
impl Add<UnitHectostokes> for UnitHectostokes {
    type Output = UnitHectostokes;
    #[inline]
    fn add(self, _: UnitHectostokes) -> Self::Output {
        UnitHectostokes
    }
}
impl AddAssign<UnitHectostokes> for UnitHectostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitHectostokes) {}
}
impl Sub<UnitHectostokes> for UnitHectostokes {
    type Output = UnitHectostokes;
    #[inline]
    fn sub(self, _: UnitHectostokes) -> Self::Output {
        UnitHectostokes
    }
}
impl SubAssign<UnitHectostokes> for UnitHectostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectostokes) {}
}
pub struct UnitHectostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectostokesMul {
    #[inline]
    fn clone(&self) -> UnitHectostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectostokesMul {
    #[inline]
    fn eq(&self, other: &UnitHectostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectostokesMul> for i8 {
    type Output = Quantity<i8, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for i16 {
    type Output = Quantity<i16, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for i32 {
    type Output = Quantity<i32, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for i64 {
    type Output = Quantity<i64, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for i128 {
    type Output = Quantity<i128, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for isize {
    type Output = Quantity<isize, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for u8 {
    type Output = Quantity<u8, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for u16 {
    type Output = Quantity<u16, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for u32 {
    type Output = Quantity<u32, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for u64 {
    type Output = Quantity<u64, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for u128 {
    type Output = Quantity<u128, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for usize {
    type Output = Quantity<usize, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for f32 {
    type Output = Quantity<f32, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
impl Mul<UnitHectostokesMul> for f64 {
    type Output = Quantity<f64, UnitHectostokes>;
    fn mul(self, _: UnitHectostokesMul) -> Self::Output {
        Quantity::new(self, UnitHectostokes)
    }
}
pub struct UnitDecastokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecastokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecastokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecastokes {
    #[inline]
    fn clone(&self) -> UnitDecastokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecastokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecastokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecastokes {
    #[inline]
    fn eq(&self, other: &UnitDecastokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecastokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecastokes {
    fn default() -> Self {
        UnitDecastokes
    }
}
impl Add<UnitDecastokes> for UnitDecastokes {
    type Output = UnitDecastokes;
    #[inline]
    fn add(self, _: UnitDecastokes) -> Self::Output {
        UnitDecastokes
    }
}
impl AddAssign<UnitDecastokes> for UnitDecastokes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecastokes) {}
}
impl Sub<UnitDecastokes> for UnitDecastokes {
    type Output = UnitDecastokes;
    #[inline]
    fn sub(self, _: UnitDecastokes) -> Self::Output {
        UnitDecastokes
    }
}
impl SubAssign<UnitDecastokes> for UnitDecastokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecastokes) {}
}
pub struct UnitDecastokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecastokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecastokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecastokesMul {
    #[inline]
    fn clone(&self) -> UnitDecastokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecastokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecastokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecastokesMul {
    #[inline]
    fn eq(&self, other: &UnitDecastokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecastokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecastokesMul> for i8 {
    type Output = Quantity<i8, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for i16 {
    type Output = Quantity<i16, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for i32 {
    type Output = Quantity<i32, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for i64 {
    type Output = Quantity<i64, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for i128 {
    type Output = Quantity<i128, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for isize {
    type Output = Quantity<isize, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for u8 {
    type Output = Quantity<u8, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for u16 {
    type Output = Quantity<u16, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for u32 {
    type Output = Quantity<u32, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for u64 {
    type Output = Quantity<u64, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for u128 {
    type Output = Quantity<u128, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for usize {
    type Output = Quantity<usize, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for f32 {
    type Output = Quantity<f32, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
impl Mul<UnitDecastokesMul> for f64 {
    type Output = Quantity<f64, UnitDecastokes>;
    fn mul(self, _: UnitDecastokesMul) -> Self::Output {
        Quantity::new(self, UnitDecastokes)
    }
}
pub struct UnitDecistokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecistokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecistokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecistokes {
    #[inline]
    fn clone(&self) -> UnitDecistokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecistokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecistokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecistokes {
    #[inline]
    fn eq(&self, other: &UnitDecistokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecistokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecistokes {
    fn default() -> Self {
        UnitDecistokes
    }
}
impl Add<UnitDecistokes> for UnitDecistokes {
    type Output = UnitDecistokes;
    #[inline]
    fn add(self, _: UnitDecistokes) -> Self::Output {
        UnitDecistokes
    }
}
impl AddAssign<UnitDecistokes> for UnitDecistokes {
    #[inline]
    fn add_assign(&mut self, _: UnitDecistokes) {}
}
impl Sub<UnitDecistokes> for UnitDecistokes {
    type Output = UnitDecistokes;
    #[inline]
    fn sub(self, _: UnitDecistokes) -> Self::Output {
        UnitDecistokes
    }
}
impl SubAssign<UnitDecistokes> for UnitDecistokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecistokes) {}
}
pub struct UnitDecistokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecistokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecistokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecistokesMul {
    #[inline]
    fn clone(&self) -> UnitDecistokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecistokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecistokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecistokesMul {
    #[inline]
    fn eq(&self, other: &UnitDecistokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecistokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecistokesMul> for i8 {
    type Output = Quantity<i8, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for i16 {
    type Output = Quantity<i16, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for i32 {
    type Output = Quantity<i32, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for i64 {
    type Output = Quantity<i64, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for i128 {
    type Output = Quantity<i128, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for isize {
    type Output = Quantity<isize, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for u8 {
    type Output = Quantity<u8, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for u16 {
    type Output = Quantity<u16, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for u32 {
    type Output = Quantity<u32, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for u64 {
    type Output = Quantity<u64, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for u128 {
    type Output = Quantity<u128, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for usize {
    type Output = Quantity<usize, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for f32 {
    type Output = Quantity<f32, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
impl Mul<UnitDecistokesMul> for f64 {
    type Output = Quantity<f64, UnitDecistokes>;
    fn mul(self, _: UnitDecistokesMul) -> Self::Output {
        Quantity::new(self, UnitDecistokes)
    }
}
pub struct UnitCentistokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentistokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentistokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentistokes {
    #[inline]
    fn clone(&self) -> UnitCentistokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentistokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentistokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentistokes {
    #[inline]
    fn eq(&self, other: &UnitCentistokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentistokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentistokes {
    fn default() -> Self {
        UnitCentistokes
    }
}
impl Add<UnitCentistokes> for UnitCentistokes {
    type Output = UnitCentistokes;
    #[inline]
    fn add(self, _: UnitCentistokes) -> Self::Output {
        UnitCentistokes
    }
}
impl AddAssign<UnitCentistokes> for UnitCentistokes {
    #[inline]
    fn add_assign(&mut self, _: UnitCentistokes) {}
}
impl Sub<UnitCentistokes> for UnitCentistokes {
    type Output = UnitCentistokes;
    #[inline]
    fn sub(self, _: UnitCentistokes) -> Self::Output {
        UnitCentistokes
    }
}
impl SubAssign<UnitCentistokes> for UnitCentistokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentistokes) {}
}
pub struct UnitCentistokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentistokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentistokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentistokesMul {
    #[inline]
    fn clone(&self) -> UnitCentistokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentistokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentistokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentistokesMul {
    #[inline]
    fn eq(&self, other: &UnitCentistokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentistokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentistokesMul> for i8 {
    type Output = Quantity<i8, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for i16 {
    type Output = Quantity<i16, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for i32 {
    type Output = Quantity<i32, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for i64 {
    type Output = Quantity<i64, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for i128 {
    type Output = Quantity<i128, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for isize {
    type Output = Quantity<isize, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for u8 {
    type Output = Quantity<u8, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for u16 {
    type Output = Quantity<u16, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for u32 {
    type Output = Quantity<u32, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for u64 {
    type Output = Quantity<u64, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for u128 {
    type Output = Quantity<u128, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for usize {
    type Output = Quantity<usize, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for f32 {
    type Output = Quantity<f32, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
impl Mul<UnitCentistokesMul> for f64 {
    type Output = Quantity<f64, UnitCentistokes>;
    fn mul(self, _: UnitCentistokesMul) -> Self::Output {
        Quantity::new(self, UnitCentistokes)
    }
}
pub struct UnitMillistokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillistokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillistokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillistokes {
    #[inline]
    fn clone(&self) -> UnitMillistokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillistokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillistokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillistokes {
    #[inline]
    fn eq(&self, other: &UnitMillistokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillistokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillistokes {
    fn default() -> Self {
        UnitMillistokes
    }
}
impl Add<UnitMillistokes> for UnitMillistokes {
    type Output = UnitMillistokes;
    #[inline]
    fn add(self, _: UnitMillistokes) -> Self::Output {
        UnitMillistokes
    }
}
impl AddAssign<UnitMillistokes> for UnitMillistokes {
    #[inline]
    fn add_assign(&mut self, _: UnitMillistokes) {}
}
impl Sub<UnitMillistokes> for UnitMillistokes {
    type Output = UnitMillistokes;
    #[inline]
    fn sub(self, _: UnitMillistokes) -> Self::Output {
        UnitMillistokes
    }
}
impl SubAssign<UnitMillistokes> for UnitMillistokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillistokes) {}
}
pub struct UnitMillistokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillistokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillistokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillistokesMul {
    #[inline]
    fn clone(&self) -> UnitMillistokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillistokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillistokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillistokesMul {
    #[inline]
    fn eq(&self, other: &UnitMillistokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillistokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillistokesMul> for i8 {
    type Output = Quantity<i8, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for i16 {
    type Output = Quantity<i16, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for i32 {
    type Output = Quantity<i32, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for i64 {
    type Output = Quantity<i64, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for i128 {
    type Output = Quantity<i128, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for isize {
    type Output = Quantity<isize, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for u8 {
    type Output = Quantity<u8, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for u16 {
    type Output = Quantity<u16, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for u32 {
    type Output = Quantity<u32, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for u64 {
    type Output = Quantity<u64, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for u128 {
    type Output = Quantity<u128, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for usize {
    type Output = Quantity<usize, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for f32 {
    type Output = Quantity<f32, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
impl Mul<UnitMillistokesMul> for f64 {
    type Output = Quantity<f64, UnitMillistokes>;
    fn mul(self, _: UnitMillistokesMul) -> Self::Output {
        Quantity::new(self, UnitMillistokes)
    }
}
pub struct UnitMicrostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrostokes {
    #[inline]
    fn clone(&self) -> UnitMicrostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrostokes {
    #[inline]
    fn eq(&self, other: &UnitMicrostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrostokes {
    fn default() -> Self {
        UnitMicrostokes
    }
}
impl Add<UnitMicrostokes> for UnitMicrostokes {
    type Output = UnitMicrostokes;
    #[inline]
    fn add(self, _: UnitMicrostokes) -> Self::Output {
        UnitMicrostokes
    }
}
impl AddAssign<UnitMicrostokes> for UnitMicrostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrostokes) {}
}
impl Sub<UnitMicrostokes> for UnitMicrostokes {
    type Output = UnitMicrostokes;
    #[inline]
    fn sub(self, _: UnitMicrostokes) -> Self::Output {
        UnitMicrostokes
    }
}
impl SubAssign<UnitMicrostokes> for UnitMicrostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrostokes) {}
}
pub struct UnitMicrostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrostokesMul {
    #[inline]
    fn clone(&self) -> UnitMicrostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrostokesMul {
    #[inline]
    fn eq(&self, other: &UnitMicrostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrostokesMul> for i8 {
    type Output = Quantity<i8, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for i16 {
    type Output = Quantity<i16, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for i32 {
    type Output = Quantity<i32, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for i64 {
    type Output = Quantity<i64, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for i128 {
    type Output = Quantity<i128, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for isize {
    type Output = Quantity<isize, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for u8 {
    type Output = Quantity<u8, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for u16 {
    type Output = Quantity<u16, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for u32 {
    type Output = Quantity<u32, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for u64 {
    type Output = Quantity<u64, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for u128 {
    type Output = Quantity<u128, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for usize {
    type Output = Quantity<usize, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for f32 {
    type Output = Quantity<f32, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
impl Mul<UnitMicrostokesMul> for f64 {
    type Output = Quantity<f64, UnitMicrostokes>;
    fn mul(self, _: UnitMicrostokesMul) -> Self::Output {
        Quantity::new(self, UnitMicrostokes)
    }
}
pub struct UnitNanostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanostokes {
    #[inline]
    fn clone(&self) -> UnitNanostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanostokes {
    #[inline]
    fn eq(&self, other: &UnitNanostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanostokes {
    fn default() -> Self {
        UnitNanostokes
    }
}
impl Add<UnitNanostokes> for UnitNanostokes {
    type Output = UnitNanostokes;
    #[inline]
    fn add(self, _: UnitNanostokes) -> Self::Output {
        UnitNanostokes
    }
}
impl AddAssign<UnitNanostokes> for UnitNanostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitNanostokes) {}
}
impl Sub<UnitNanostokes> for UnitNanostokes {
    type Output = UnitNanostokes;
    #[inline]
    fn sub(self, _: UnitNanostokes) -> Self::Output {
        UnitNanostokes
    }
}
impl SubAssign<UnitNanostokes> for UnitNanostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanostokes) {}
}
pub struct UnitNanostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanostokesMul {
    #[inline]
    fn clone(&self) -> UnitNanostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanostokesMul {
    #[inline]
    fn eq(&self, other: &UnitNanostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanostokesMul> for i8 {
    type Output = Quantity<i8, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for i16 {
    type Output = Quantity<i16, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for i32 {
    type Output = Quantity<i32, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for i64 {
    type Output = Quantity<i64, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for i128 {
    type Output = Quantity<i128, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for isize {
    type Output = Quantity<isize, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for u8 {
    type Output = Quantity<u8, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for u16 {
    type Output = Quantity<u16, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for u32 {
    type Output = Quantity<u32, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for u64 {
    type Output = Quantity<u64, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for u128 {
    type Output = Quantity<u128, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for usize {
    type Output = Quantity<usize, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for f32 {
    type Output = Quantity<f32, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
impl Mul<UnitNanostokesMul> for f64 {
    type Output = Quantity<f64, UnitNanostokes>;
    fn mul(self, _: UnitNanostokesMul) -> Self::Output {
        Quantity::new(self, UnitNanostokes)
    }
}
pub struct UnitPicostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicostokes {
    #[inline]
    fn clone(&self) -> UnitPicostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicostokes {
    #[inline]
    fn eq(&self, other: &UnitPicostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicostokes {
    fn default() -> Self {
        UnitPicostokes
    }
}
impl Add<UnitPicostokes> for UnitPicostokes {
    type Output = UnitPicostokes;
    #[inline]
    fn add(self, _: UnitPicostokes) -> Self::Output {
        UnitPicostokes
    }
}
impl AddAssign<UnitPicostokes> for UnitPicostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitPicostokes) {}
}
impl Sub<UnitPicostokes> for UnitPicostokes {
    type Output = UnitPicostokes;
    #[inline]
    fn sub(self, _: UnitPicostokes) -> Self::Output {
        UnitPicostokes
    }
}
impl SubAssign<UnitPicostokes> for UnitPicostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicostokes) {}
}
pub struct UnitPicostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicostokesMul {
    #[inline]
    fn clone(&self) -> UnitPicostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicostokesMul {
    #[inline]
    fn eq(&self, other: &UnitPicostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicostokesMul> for i8 {
    type Output = Quantity<i8, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for i16 {
    type Output = Quantity<i16, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for i32 {
    type Output = Quantity<i32, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for i64 {
    type Output = Quantity<i64, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for i128 {
    type Output = Quantity<i128, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for isize {
    type Output = Quantity<isize, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for u8 {
    type Output = Quantity<u8, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for u16 {
    type Output = Quantity<u16, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for u32 {
    type Output = Quantity<u32, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for u64 {
    type Output = Quantity<u64, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for u128 {
    type Output = Quantity<u128, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for usize {
    type Output = Quantity<usize, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for f32 {
    type Output = Quantity<f32, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
impl Mul<UnitPicostokesMul> for f64 {
    type Output = Quantity<f64, UnitPicostokes>;
    fn mul(self, _: UnitPicostokesMul) -> Self::Output {
        Quantity::new(self, UnitPicostokes)
    }
}
pub struct UnitFemtostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtostokes {
    #[inline]
    fn clone(&self) -> UnitFemtostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtostokes {
    #[inline]
    fn eq(&self, other: &UnitFemtostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtostokes {
    fn default() -> Self {
        UnitFemtostokes
    }
}
impl Add<UnitFemtostokes> for UnitFemtostokes {
    type Output = UnitFemtostokes;
    #[inline]
    fn add(self, _: UnitFemtostokes) -> Self::Output {
        UnitFemtostokes
    }
}
impl AddAssign<UnitFemtostokes> for UnitFemtostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtostokes) {}
}
impl Sub<UnitFemtostokes> for UnitFemtostokes {
    type Output = UnitFemtostokes;
    #[inline]
    fn sub(self, _: UnitFemtostokes) -> Self::Output {
        UnitFemtostokes
    }
}
impl SubAssign<UnitFemtostokes> for UnitFemtostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtostokes) {}
}
pub struct UnitFemtostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtostokesMul {
    #[inline]
    fn clone(&self) -> UnitFemtostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtostokesMul {
    #[inline]
    fn eq(&self, other: &UnitFemtostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtostokesMul> for i8 {
    type Output = Quantity<i8, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for i16 {
    type Output = Quantity<i16, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for i32 {
    type Output = Quantity<i32, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for i64 {
    type Output = Quantity<i64, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for i128 {
    type Output = Quantity<i128, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for isize {
    type Output = Quantity<isize, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for u8 {
    type Output = Quantity<u8, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for u16 {
    type Output = Quantity<u16, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for u32 {
    type Output = Quantity<u32, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for u64 {
    type Output = Quantity<u64, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for u128 {
    type Output = Quantity<u128, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for usize {
    type Output = Quantity<usize, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for f32 {
    type Output = Quantity<f32, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
impl Mul<UnitFemtostokesMul> for f64 {
    type Output = Quantity<f64, UnitFemtostokes>;
    fn mul(self, _: UnitFemtostokesMul) -> Self::Output {
        Quantity::new(self, UnitFemtostokes)
    }
}
pub struct UnitAttostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttostokes {
    #[inline]
    fn clone(&self) -> UnitAttostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttostokes {
    #[inline]
    fn eq(&self, other: &UnitAttostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttostokes {
    fn default() -> Self {
        UnitAttostokes
    }
}
impl Add<UnitAttostokes> for UnitAttostokes {
    type Output = UnitAttostokes;
    #[inline]
    fn add(self, _: UnitAttostokes) -> Self::Output {
        UnitAttostokes
    }
}
impl AddAssign<UnitAttostokes> for UnitAttostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitAttostokes) {}
}
impl Sub<UnitAttostokes> for UnitAttostokes {
    type Output = UnitAttostokes;
    #[inline]
    fn sub(self, _: UnitAttostokes) -> Self::Output {
        UnitAttostokes
    }
}
impl SubAssign<UnitAttostokes> for UnitAttostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttostokes) {}
}
pub struct UnitAttostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttostokesMul {
    #[inline]
    fn clone(&self) -> UnitAttostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttostokesMul {
    #[inline]
    fn eq(&self, other: &UnitAttostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttostokesMul> for i8 {
    type Output = Quantity<i8, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for i16 {
    type Output = Quantity<i16, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for i32 {
    type Output = Quantity<i32, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for i64 {
    type Output = Quantity<i64, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for i128 {
    type Output = Quantity<i128, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for isize {
    type Output = Quantity<isize, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for u8 {
    type Output = Quantity<u8, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for u16 {
    type Output = Quantity<u16, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for u32 {
    type Output = Quantity<u32, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for u64 {
    type Output = Quantity<u64, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for u128 {
    type Output = Quantity<u128, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for usize {
    type Output = Quantity<usize, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for f32 {
    type Output = Quantity<f32, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
impl Mul<UnitAttostokesMul> for f64 {
    type Output = Quantity<f64, UnitAttostokes>;
    fn mul(self, _: UnitAttostokesMul) -> Self::Output {
        Quantity::new(self, UnitAttostokes)
    }
}
pub struct UnitZeptostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptostokes {
    #[inline]
    fn clone(&self) -> UnitZeptostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptostokes {
    #[inline]
    fn eq(&self, other: &UnitZeptostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptostokes {
    fn default() -> Self {
        UnitZeptostokes
    }
}
impl Add<UnitZeptostokes> for UnitZeptostokes {
    type Output = UnitZeptostokes;
    #[inline]
    fn add(self, _: UnitZeptostokes) -> Self::Output {
        UnitZeptostokes
    }
}
impl AddAssign<UnitZeptostokes> for UnitZeptostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptostokes) {}
}
impl Sub<UnitZeptostokes> for UnitZeptostokes {
    type Output = UnitZeptostokes;
    #[inline]
    fn sub(self, _: UnitZeptostokes) -> Self::Output {
        UnitZeptostokes
    }
}
impl SubAssign<UnitZeptostokes> for UnitZeptostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptostokes) {}
}
pub struct UnitZeptostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptostokesMul {
    #[inline]
    fn clone(&self) -> UnitZeptostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptostokesMul {
    #[inline]
    fn eq(&self, other: &UnitZeptostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptostokesMul> for i8 {
    type Output = Quantity<i8, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for i16 {
    type Output = Quantity<i16, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for i32 {
    type Output = Quantity<i32, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for i64 {
    type Output = Quantity<i64, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for i128 {
    type Output = Quantity<i128, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for isize {
    type Output = Quantity<isize, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for u8 {
    type Output = Quantity<u8, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for u16 {
    type Output = Quantity<u16, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for u32 {
    type Output = Quantity<u32, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for u64 {
    type Output = Quantity<u64, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for u128 {
    type Output = Quantity<u128, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for usize {
    type Output = Quantity<usize, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for f32 {
    type Output = Quantity<f32, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
impl Mul<UnitZeptostokesMul> for f64 {
    type Output = Quantity<f64, UnitZeptostokes>;
    fn mul(self, _: UnitZeptostokesMul) -> Self::Output {
        Quantity::new(self, UnitZeptostokes)
    }
}
pub struct UnitYoctostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctostokes {
    #[inline]
    fn clone(&self) -> UnitYoctostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctostokes {
    #[inline]
    fn eq(&self, other: &UnitYoctostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctostokes {
    fn default() -> Self {
        UnitYoctostokes
    }
}
impl Add<UnitYoctostokes> for UnitYoctostokes {
    type Output = UnitYoctostokes;
    #[inline]
    fn add(self, _: UnitYoctostokes) -> Self::Output {
        UnitYoctostokes
    }
}
impl AddAssign<UnitYoctostokes> for UnitYoctostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctostokes) {}
}
impl Sub<UnitYoctostokes> for UnitYoctostokes {
    type Output = UnitYoctostokes;
    #[inline]
    fn sub(self, _: UnitYoctostokes) -> Self::Output {
        UnitYoctostokes
    }
}
impl SubAssign<UnitYoctostokes> for UnitYoctostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctostokes) {}
}
pub struct UnitYoctostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctostokesMul {
    #[inline]
    fn clone(&self) -> UnitYoctostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctostokesMul {
    #[inline]
    fn eq(&self, other: &UnitYoctostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctostokesMul> for i8 {
    type Output = Quantity<i8, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for i16 {
    type Output = Quantity<i16, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for i32 {
    type Output = Quantity<i32, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for i64 {
    type Output = Quantity<i64, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for i128 {
    type Output = Quantity<i128, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for isize {
    type Output = Quantity<isize, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for u8 {
    type Output = Quantity<u8, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for u16 {
    type Output = Quantity<u16, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for u32 {
    type Output = Quantity<u32, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for u64 {
    type Output = Quantity<u64, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for u128 {
    type Output = Quantity<u128, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for usize {
    type Output = Quantity<usize, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for f32 {
    type Output = Quantity<f32, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
impl Mul<UnitYoctostokesMul> for f64 {
    type Output = Quantity<f64, UnitYoctostokes>;
    fn mul(self, _: UnitYoctostokesMul) -> Self::Output {
        Quantity::new(self, UnitYoctostokes)
    }
}
pub struct UnitRontostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontostokes {
    #[inline]
    fn clone(&self) -> UnitRontostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontostokes {
    #[inline]
    fn eq(&self, other: &UnitRontostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontostokes {
    fn default() -> Self {
        UnitRontostokes
    }
}
impl Add<UnitRontostokes> for UnitRontostokes {
    type Output = UnitRontostokes;
    #[inline]
    fn add(self, _: UnitRontostokes) -> Self::Output {
        UnitRontostokes
    }
}
impl AddAssign<UnitRontostokes> for UnitRontostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitRontostokes) {}
}
impl Sub<UnitRontostokes> for UnitRontostokes {
    type Output = UnitRontostokes;
    #[inline]
    fn sub(self, _: UnitRontostokes) -> Self::Output {
        UnitRontostokes
    }
}
impl SubAssign<UnitRontostokes> for UnitRontostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontostokes) {}
}
pub struct UnitRontostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontostokesMul {
    #[inline]
    fn clone(&self) -> UnitRontostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontostokesMul {
    #[inline]
    fn eq(&self, other: &UnitRontostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontostokesMul> for i8 {
    type Output = Quantity<i8, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for i16 {
    type Output = Quantity<i16, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for i32 {
    type Output = Quantity<i32, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for i64 {
    type Output = Quantity<i64, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for i128 {
    type Output = Quantity<i128, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for isize {
    type Output = Quantity<isize, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for u8 {
    type Output = Quantity<u8, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for u16 {
    type Output = Quantity<u16, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for u32 {
    type Output = Quantity<u32, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for u64 {
    type Output = Quantity<u64, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for u128 {
    type Output = Quantity<u128, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for usize {
    type Output = Quantity<usize, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for f32 {
    type Output = Quantity<f32, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
impl Mul<UnitRontostokesMul> for f64 {
    type Output = Quantity<f64, UnitRontostokes>;
    fn mul(self, _: UnitRontostokesMul) -> Self::Output {
        Quantity::new(self, UnitRontostokes)
    }
}
pub struct UnitQuectostokes;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectostokes {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectostokes")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectostokes {
    #[inline]
    fn clone(&self) -> UnitQuectostokes {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectostokes {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectostokes {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectostokes {
    #[inline]
    fn eq(&self, other: &UnitQuectostokes) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectostokes {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectostokes {
    fn default() -> Self {
        UnitQuectostokes
    }
}
impl Add<UnitQuectostokes> for UnitQuectostokes {
    type Output = UnitQuectostokes;
    #[inline]
    fn add(self, _: UnitQuectostokes) -> Self::Output {
        UnitQuectostokes
    }
}
impl AddAssign<UnitQuectostokes> for UnitQuectostokes {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectostokes) {}
}
impl Sub<UnitQuectostokes> for UnitQuectostokes {
    type Output = UnitQuectostokes;
    #[inline]
    fn sub(self, _: UnitQuectostokes) -> Self::Output {
        UnitQuectostokes
    }
}
impl SubAssign<UnitQuectostokes> for UnitQuectostokes {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectostokes) {}
}
pub struct UnitQuectostokesMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectostokesMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectostokesMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectostokesMul {
    #[inline]
    fn clone(&self) -> UnitQuectostokesMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectostokesMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectostokesMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectostokesMul {
    #[inline]
    fn eq(&self, other: &UnitQuectostokesMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectostokesMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectostokesMul> for i8 {
    type Output = Quantity<i8, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for i16 {
    type Output = Quantity<i16, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for i32 {
    type Output = Quantity<i32, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for i64 {
    type Output = Quantity<i64, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for i128 {
    type Output = Quantity<i128, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for isize {
    type Output = Quantity<isize, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for u8 {
    type Output = Quantity<u8, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for u16 {
    type Output = Quantity<u16, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for u32 {
    type Output = Quantity<u32, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for u64 {
    type Output = Quantity<u64, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for u128 {
    type Output = Quantity<u128, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for usize {
    type Output = Quantity<usize, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for f32 {
    type Output = Quantity<f32, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
impl Mul<UnitQuectostokesMul> for f64 {
    type Output = Quantity<f64, UnitQuectostokes>;
    fn mul(self, _: UnitQuectostokesMul) -> Self::Output {
        Quantity::new(self, UnitQuectostokes)
    }
}
pub type Stokes<T> = Quantity<T, UnitStokes>;
#[allow(non_upper_case_globals)]
pub static Stokes: UnitStokesMul = UnitStokesMul;
pub type Quettastokes<T> = Quantity<T, UnitQuettastokes>;
#[allow(non_upper_case_globals)]
pub static Quettastokes: UnitQuettastokesMul = UnitQuettastokesMul;
pub type Ronnastokes<T> = Quantity<T, UnitRonnastokes>;
#[allow(non_upper_case_globals)]
pub static Ronnastokes: UnitRonnastokesMul = UnitRonnastokesMul;
pub type Yottastokes<T> = Quantity<T, UnitYottastokes>;
#[allow(non_upper_case_globals)]
pub static Yottastokes: UnitYottastokesMul = UnitYottastokesMul;
pub type Zettastokes<T> = Quantity<T, UnitZettastokes>;
#[allow(non_upper_case_globals)]
pub static Zettastokes: UnitZettastokesMul = UnitZettastokesMul;
pub type Exastokes<T> = Quantity<T, UnitExastokes>;
#[allow(non_upper_case_globals)]
pub static Exastokes: UnitExastokesMul = UnitExastokesMul;
pub type Petastokes<T> = Quantity<T, UnitPetastokes>;
#[allow(non_upper_case_globals)]
pub static Petastokes: UnitPetastokesMul = UnitPetastokesMul;
pub type Terastokes<T> = Quantity<T, UnitTerastokes>;
#[allow(non_upper_case_globals)]
pub static Terastokes: UnitTerastokesMul = UnitTerastokesMul;
pub type Gigastokes<T> = Quantity<T, UnitGigastokes>;
#[allow(non_upper_case_globals)]
pub static Gigastokes: UnitGigastokesMul = UnitGigastokesMul;
pub type Megastokes<T> = Quantity<T, UnitMegastokes>;
#[allow(non_upper_case_globals)]
pub static Megastokes: UnitMegastokesMul = UnitMegastokesMul;
pub type Kilostokes<T> = Quantity<T, UnitKilostokes>;
#[allow(non_upper_case_globals)]
pub static Kilostokes: UnitKilostokesMul = UnitKilostokesMul;
pub type Hectostokes<T> = Quantity<T, UnitHectostokes>;
#[allow(non_upper_case_globals)]
pub static Hectostokes: UnitHectostokesMul = UnitHectostokesMul;
pub type Decastokes<T> = Quantity<T, UnitDecastokes>;
#[allow(non_upper_case_globals)]
pub static Decastokes: UnitDecastokesMul = UnitDecastokesMul;
pub type Decistokes<T> = Quantity<T, UnitDecistokes>;
#[allow(non_upper_case_globals)]
pub static Decistokes: UnitDecistokesMul = UnitDecistokesMul;
pub type Centistokes<T> = Quantity<T, UnitCentistokes>;
#[allow(non_upper_case_globals)]
pub static Centistokes: UnitCentistokesMul = UnitCentistokesMul;
pub type Millistokes<T> = Quantity<T, UnitMillistokes>;
#[allow(non_upper_case_globals)]
pub static Millistokes: UnitMillistokesMul = UnitMillistokesMul;
pub type Microstokes<T> = Quantity<T, UnitMicrostokes>;
#[allow(non_upper_case_globals)]
pub static Microstokes: UnitMicrostokesMul = UnitMicrostokesMul;
pub type Nanostokes<T> = Quantity<T, UnitNanostokes>;
#[allow(non_upper_case_globals)]
pub static Nanostokes: UnitNanostokesMul = UnitNanostokesMul;
pub type Picostokes<T> = Quantity<T, UnitPicostokes>;
#[allow(non_upper_case_globals)]
pub static Picostokes: UnitPicostokesMul = UnitPicostokesMul;
pub type Femtostokes<T> = Quantity<T, UnitFemtostokes>;
#[allow(non_upper_case_globals)]
pub static Femtostokes: UnitFemtostokesMul = UnitFemtostokesMul;
pub type Attostokes<T> = Quantity<T, UnitAttostokes>;
#[allow(non_upper_case_globals)]
pub static Attostokes: UnitAttostokesMul = UnitAttostokesMul;
pub type Zeptostokes<T> = Quantity<T, UnitZeptostokes>;
#[allow(non_upper_case_globals)]
pub static Zeptostokes: UnitZeptostokesMul = UnitZeptostokesMul;
pub type Yoctostokes<T> = Quantity<T, UnitYoctostokes>;
#[allow(non_upper_case_globals)]
pub static Yoctostokes: UnitYoctostokesMul = UnitYoctostokesMul;
pub type Rontostokes<T> = Quantity<T, UnitRontostokes>;
#[allow(non_upper_case_globals)]
pub static Rontostokes: UnitRontostokesMul = UnitRontostokesMul;
pub type Quectostokes<T> = Quantity<T, UnitQuectostokes>;
#[allow(non_upper_case_globals)]
pub static Quectostokes: UnitQuectostokesMul = UnitQuectostokesMul;
pub struct UnitStilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitStilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitStilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitStilbs {
    #[inline]
    fn clone(&self) -> UnitStilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitStilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitStilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitStilbs {
    #[inline]
    fn eq(&self, other: &UnitStilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitStilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitStilbs {
    fn default() -> Self {
        UnitStilbs
    }
}
impl Add<UnitStilbs> for UnitStilbs {
    type Output = UnitStilbs;
    #[inline]
    fn add(self, _: UnitStilbs) -> Self::Output {
        UnitStilbs
    }
}
impl AddAssign<UnitStilbs> for UnitStilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitStilbs) {}
}
impl Sub<UnitStilbs> for UnitStilbs {
    type Output = UnitStilbs;
    #[inline]
    fn sub(self, _: UnitStilbs) -> Self::Output {
        UnitStilbs
    }
}
impl SubAssign<UnitStilbs> for UnitStilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitStilbs) {}
}
pub struct UnitStilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitStilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitStilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitStilbsMul {
    #[inline]
    fn clone(&self) -> UnitStilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitStilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitStilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitStilbsMul {
    #[inline]
    fn eq(&self, other: &UnitStilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitStilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitStilbsMul> for i8 {
    type Output = Quantity<i8, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for i16 {
    type Output = Quantity<i16, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for i32 {
    type Output = Quantity<i32, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for i64 {
    type Output = Quantity<i64, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for i128 {
    type Output = Quantity<i128, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for isize {
    type Output = Quantity<isize, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for u8 {
    type Output = Quantity<u8, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for u16 {
    type Output = Quantity<u16, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for u32 {
    type Output = Quantity<u32, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for u64 {
    type Output = Quantity<u64, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for u128 {
    type Output = Quantity<u128, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for usize {
    type Output = Quantity<usize, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for f32 {
    type Output = Quantity<f32, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
impl Mul<UnitStilbsMul> for f64 {
    type Output = Quantity<f64, UnitStilbs>;
    fn mul(self, _: UnitStilbsMul) -> Self::Output {
        Quantity::new(self, UnitStilbs)
    }
}
pub struct UnitQuettastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettastilbs {
    #[inline]
    fn clone(&self) -> UnitQuettastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettastilbs {
    #[inline]
    fn eq(&self, other: &UnitQuettastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettastilbs {
    fn default() -> Self {
        UnitQuettastilbs
    }
}
impl Add<UnitQuettastilbs> for UnitQuettastilbs {
    type Output = UnitQuettastilbs;
    #[inline]
    fn add(self, _: UnitQuettastilbs) -> Self::Output {
        UnitQuettastilbs
    }
}
impl AddAssign<UnitQuettastilbs> for UnitQuettastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettastilbs) {}
}
impl Sub<UnitQuettastilbs> for UnitQuettastilbs {
    type Output = UnitQuettastilbs;
    #[inline]
    fn sub(self, _: UnitQuettastilbs) -> Self::Output {
        UnitQuettastilbs
    }
}
impl SubAssign<UnitQuettastilbs> for UnitQuettastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettastilbs) {}
}
pub struct UnitQuettastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettastilbsMul {
    #[inline]
    fn clone(&self) -> UnitQuettastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettastilbsMul> for i8 {
    type Output = Quantity<i8, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for i16 {
    type Output = Quantity<i16, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for i32 {
    type Output = Quantity<i32, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for i64 {
    type Output = Quantity<i64, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for i128 {
    type Output = Quantity<i128, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for isize {
    type Output = Quantity<isize, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for u8 {
    type Output = Quantity<u8, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for u16 {
    type Output = Quantity<u16, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for u32 {
    type Output = Quantity<u32, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for u64 {
    type Output = Quantity<u64, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for u128 {
    type Output = Quantity<u128, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for usize {
    type Output = Quantity<usize, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for f32 {
    type Output = Quantity<f32, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
impl Mul<UnitQuettastilbsMul> for f64 {
    type Output = Quantity<f64, UnitQuettastilbs>;
    fn mul(self, _: UnitQuettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuettastilbs)
    }
}
pub struct UnitRonnastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnastilbs {
    #[inline]
    fn clone(&self) -> UnitRonnastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnastilbs {
    #[inline]
    fn eq(&self, other: &UnitRonnastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnastilbs {
    fn default() -> Self {
        UnitRonnastilbs
    }
}
impl Add<UnitRonnastilbs> for UnitRonnastilbs {
    type Output = UnitRonnastilbs;
    #[inline]
    fn add(self, _: UnitRonnastilbs) -> Self::Output {
        UnitRonnastilbs
    }
}
impl AddAssign<UnitRonnastilbs> for UnitRonnastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnastilbs) {}
}
impl Sub<UnitRonnastilbs> for UnitRonnastilbs {
    type Output = UnitRonnastilbs;
    #[inline]
    fn sub(self, _: UnitRonnastilbs) -> Self::Output {
        UnitRonnastilbs
    }
}
impl SubAssign<UnitRonnastilbs> for UnitRonnastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnastilbs) {}
}
pub struct UnitRonnastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnastilbsMul {
    #[inline]
    fn clone(&self) -> UnitRonnastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnastilbsMul> for i8 {
    type Output = Quantity<i8, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for i16 {
    type Output = Quantity<i16, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for i32 {
    type Output = Quantity<i32, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for i64 {
    type Output = Quantity<i64, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for i128 {
    type Output = Quantity<i128, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for isize {
    type Output = Quantity<isize, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for u8 {
    type Output = Quantity<u8, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for u16 {
    type Output = Quantity<u16, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for u32 {
    type Output = Quantity<u32, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for u64 {
    type Output = Quantity<u64, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for u128 {
    type Output = Quantity<u128, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for usize {
    type Output = Quantity<usize, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for f32 {
    type Output = Quantity<f32, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
impl Mul<UnitRonnastilbsMul> for f64 {
    type Output = Quantity<f64, UnitRonnastilbs>;
    fn mul(self, _: UnitRonnastilbsMul) -> Self::Output {
        Quantity::new(self, UnitRonnastilbs)
    }
}
pub struct UnitYottastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottastilbs {
    #[inline]
    fn clone(&self) -> UnitYottastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottastilbs {
    #[inline]
    fn eq(&self, other: &UnitYottastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottastilbs {
    fn default() -> Self {
        UnitYottastilbs
    }
}
impl Add<UnitYottastilbs> for UnitYottastilbs {
    type Output = UnitYottastilbs;
    #[inline]
    fn add(self, _: UnitYottastilbs) -> Self::Output {
        UnitYottastilbs
    }
}
impl AddAssign<UnitYottastilbs> for UnitYottastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitYottastilbs) {}
}
impl Sub<UnitYottastilbs> for UnitYottastilbs {
    type Output = UnitYottastilbs;
    #[inline]
    fn sub(self, _: UnitYottastilbs) -> Self::Output {
        UnitYottastilbs
    }
}
impl SubAssign<UnitYottastilbs> for UnitYottastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottastilbs) {}
}
pub struct UnitYottastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottastilbsMul {
    #[inline]
    fn clone(&self) -> UnitYottastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitYottastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottastilbsMul> for i8 {
    type Output = Quantity<i8, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for i16 {
    type Output = Quantity<i16, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for i32 {
    type Output = Quantity<i32, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for i64 {
    type Output = Quantity<i64, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for i128 {
    type Output = Quantity<i128, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for isize {
    type Output = Quantity<isize, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for u8 {
    type Output = Quantity<u8, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for u16 {
    type Output = Quantity<u16, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for u32 {
    type Output = Quantity<u32, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for u64 {
    type Output = Quantity<u64, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for u128 {
    type Output = Quantity<u128, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for usize {
    type Output = Quantity<usize, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for f32 {
    type Output = Quantity<f32, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
impl Mul<UnitYottastilbsMul> for f64 {
    type Output = Quantity<f64, UnitYottastilbs>;
    fn mul(self, _: UnitYottastilbsMul) -> Self::Output {
        Quantity::new(self, UnitYottastilbs)
    }
}
pub struct UnitZettastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettastilbs {
    #[inline]
    fn clone(&self) -> UnitZettastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettastilbs {
    #[inline]
    fn eq(&self, other: &UnitZettastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettastilbs {
    fn default() -> Self {
        UnitZettastilbs
    }
}
impl Add<UnitZettastilbs> for UnitZettastilbs {
    type Output = UnitZettastilbs;
    #[inline]
    fn add(self, _: UnitZettastilbs) -> Self::Output {
        UnitZettastilbs
    }
}
impl AddAssign<UnitZettastilbs> for UnitZettastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitZettastilbs) {}
}
impl Sub<UnitZettastilbs> for UnitZettastilbs {
    type Output = UnitZettastilbs;
    #[inline]
    fn sub(self, _: UnitZettastilbs) -> Self::Output {
        UnitZettastilbs
    }
}
impl SubAssign<UnitZettastilbs> for UnitZettastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettastilbs) {}
}
pub struct UnitZettastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettastilbsMul {
    #[inline]
    fn clone(&self) -> UnitZettastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitZettastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettastilbsMul> for i8 {
    type Output = Quantity<i8, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for i16 {
    type Output = Quantity<i16, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for i32 {
    type Output = Quantity<i32, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for i64 {
    type Output = Quantity<i64, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for i128 {
    type Output = Quantity<i128, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for isize {
    type Output = Quantity<isize, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for u8 {
    type Output = Quantity<u8, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for u16 {
    type Output = Quantity<u16, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for u32 {
    type Output = Quantity<u32, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for u64 {
    type Output = Quantity<u64, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for u128 {
    type Output = Quantity<u128, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for usize {
    type Output = Quantity<usize, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for f32 {
    type Output = Quantity<f32, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
impl Mul<UnitZettastilbsMul> for f64 {
    type Output = Quantity<f64, UnitZettastilbs>;
    fn mul(self, _: UnitZettastilbsMul) -> Self::Output {
        Quantity::new(self, UnitZettastilbs)
    }
}
pub struct UnitExastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExastilbs {
    #[inline]
    fn clone(&self) -> UnitExastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExastilbs {
    #[inline]
    fn eq(&self, other: &UnitExastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExastilbs {
    fn default() -> Self {
        UnitExastilbs
    }
}
impl Add<UnitExastilbs> for UnitExastilbs {
    type Output = UnitExastilbs;
    #[inline]
    fn add(self, _: UnitExastilbs) -> Self::Output {
        UnitExastilbs
    }
}
impl AddAssign<UnitExastilbs> for UnitExastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitExastilbs) {}
}
impl Sub<UnitExastilbs> for UnitExastilbs {
    type Output = UnitExastilbs;
    #[inline]
    fn sub(self, _: UnitExastilbs) -> Self::Output {
        UnitExastilbs
    }
}
impl SubAssign<UnitExastilbs> for UnitExastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitExastilbs) {}
}
pub struct UnitExastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExastilbsMul {
    #[inline]
    fn clone(&self) -> UnitExastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitExastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExastilbsMul> for i8 {
    type Output = Quantity<i8, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for i16 {
    type Output = Quantity<i16, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for i32 {
    type Output = Quantity<i32, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for i64 {
    type Output = Quantity<i64, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for i128 {
    type Output = Quantity<i128, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for isize {
    type Output = Quantity<isize, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for u8 {
    type Output = Quantity<u8, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for u16 {
    type Output = Quantity<u16, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for u32 {
    type Output = Quantity<u32, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for u64 {
    type Output = Quantity<u64, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for u128 {
    type Output = Quantity<u128, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for usize {
    type Output = Quantity<usize, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for f32 {
    type Output = Quantity<f32, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
impl Mul<UnitExastilbsMul> for f64 {
    type Output = Quantity<f64, UnitExastilbs>;
    fn mul(self, _: UnitExastilbsMul) -> Self::Output {
        Quantity::new(self, UnitExastilbs)
    }
}
pub struct UnitPetastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetastilbs {
    #[inline]
    fn clone(&self) -> UnitPetastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetastilbs {
    #[inline]
    fn eq(&self, other: &UnitPetastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetastilbs {
    fn default() -> Self {
        UnitPetastilbs
    }
}
impl Add<UnitPetastilbs> for UnitPetastilbs {
    type Output = UnitPetastilbs;
    #[inline]
    fn add(self, _: UnitPetastilbs) -> Self::Output {
        UnitPetastilbs
    }
}
impl AddAssign<UnitPetastilbs> for UnitPetastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitPetastilbs) {}
}
impl Sub<UnitPetastilbs> for UnitPetastilbs {
    type Output = UnitPetastilbs;
    #[inline]
    fn sub(self, _: UnitPetastilbs) -> Self::Output {
        UnitPetastilbs
    }
}
impl SubAssign<UnitPetastilbs> for UnitPetastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetastilbs) {}
}
pub struct UnitPetastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetastilbsMul {
    #[inline]
    fn clone(&self) -> UnitPetastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitPetastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetastilbsMul> for i8 {
    type Output = Quantity<i8, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for i16 {
    type Output = Quantity<i16, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for i32 {
    type Output = Quantity<i32, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for i64 {
    type Output = Quantity<i64, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for i128 {
    type Output = Quantity<i128, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for isize {
    type Output = Quantity<isize, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for u8 {
    type Output = Quantity<u8, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for u16 {
    type Output = Quantity<u16, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for u32 {
    type Output = Quantity<u32, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for u64 {
    type Output = Quantity<u64, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for u128 {
    type Output = Quantity<u128, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for usize {
    type Output = Quantity<usize, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for f32 {
    type Output = Quantity<f32, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
impl Mul<UnitPetastilbsMul> for f64 {
    type Output = Quantity<f64, UnitPetastilbs>;
    fn mul(self, _: UnitPetastilbsMul) -> Self::Output {
        Quantity::new(self, UnitPetastilbs)
    }
}
pub struct UnitTerastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerastilbs {
    #[inline]
    fn clone(&self) -> UnitTerastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerastilbs {
    #[inline]
    fn eq(&self, other: &UnitTerastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerastilbs {
    fn default() -> Self {
        UnitTerastilbs
    }
}
impl Add<UnitTerastilbs> for UnitTerastilbs {
    type Output = UnitTerastilbs;
    #[inline]
    fn add(self, _: UnitTerastilbs) -> Self::Output {
        UnitTerastilbs
    }
}
impl AddAssign<UnitTerastilbs> for UnitTerastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitTerastilbs) {}
}
impl Sub<UnitTerastilbs> for UnitTerastilbs {
    type Output = UnitTerastilbs;
    #[inline]
    fn sub(self, _: UnitTerastilbs) -> Self::Output {
        UnitTerastilbs
    }
}
impl SubAssign<UnitTerastilbs> for UnitTerastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerastilbs) {}
}
pub struct UnitTerastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerastilbsMul {
    #[inline]
    fn clone(&self) -> UnitTerastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitTerastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerastilbsMul> for i8 {
    type Output = Quantity<i8, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for i16 {
    type Output = Quantity<i16, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for i32 {
    type Output = Quantity<i32, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for i64 {
    type Output = Quantity<i64, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for i128 {
    type Output = Quantity<i128, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for isize {
    type Output = Quantity<isize, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for u8 {
    type Output = Quantity<u8, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for u16 {
    type Output = Quantity<u16, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for u32 {
    type Output = Quantity<u32, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for u64 {
    type Output = Quantity<u64, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for u128 {
    type Output = Quantity<u128, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for usize {
    type Output = Quantity<usize, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for f32 {
    type Output = Quantity<f32, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
impl Mul<UnitTerastilbsMul> for f64 {
    type Output = Quantity<f64, UnitTerastilbs>;
    fn mul(self, _: UnitTerastilbsMul) -> Self::Output {
        Quantity::new(self, UnitTerastilbs)
    }
}
pub struct UnitGigastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigastilbs {
    #[inline]
    fn clone(&self) -> UnitGigastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigastilbs {
    #[inline]
    fn eq(&self, other: &UnitGigastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigastilbs {
    fn default() -> Self {
        UnitGigastilbs
    }
}
impl Add<UnitGigastilbs> for UnitGigastilbs {
    type Output = UnitGigastilbs;
    #[inline]
    fn add(self, _: UnitGigastilbs) -> Self::Output {
        UnitGigastilbs
    }
}
impl AddAssign<UnitGigastilbs> for UnitGigastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitGigastilbs) {}
}
impl Sub<UnitGigastilbs> for UnitGigastilbs {
    type Output = UnitGigastilbs;
    #[inline]
    fn sub(self, _: UnitGigastilbs) -> Self::Output {
        UnitGigastilbs
    }
}
impl SubAssign<UnitGigastilbs> for UnitGigastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigastilbs) {}
}
pub struct UnitGigastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigastilbsMul {
    #[inline]
    fn clone(&self) -> UnitGigastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitGigastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigastilbsMul> for i8 {
    type Output = Quantity<i8, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for i16 {
    type Output = Quantity<i16, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for i32 {
    type Output = Quantity<i32, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for i64 {
    type Output = Quantity<i64, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for i128 {
    type Output = Quantity<i128, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for isize {
    type Output = Quantity<isize, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for u8 {
    type Output = Quantity<u8, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for u16 {
    type Output = Quantity<u16, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for u32 {
    type Output = Quantity<u32, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for u64 {
    type Output = Quantity<u64, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for u128 {
    type Output = Quantity<u128, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for usize {
    type Output = Quantity<usize, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for f32 {
    type Output = Quantity<f32, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
impl Mul<UnitGigastilbsMul> for f64 {
    type Output = Quantity<f64, UnitGigastilbs>;
    fn mul(self, _: UnitGigastilbsMul) -> Self::Output {
        Quantity::new(self, UnitGigastilbs)
    }
}
pub struct UnitMegastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegastilbs {
    #[inline]
    fn clone(&self) -> UnitMegastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegastilbs {
    #[inline]
    fn eq(&self, other: &UnitMegastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegastilbs {
    fn default() -> Self {
        UnitMegastilbs
    }
}
impl Add<UnitMegastilbs> for UnitMegastilbs {
    type Output = UnitMegastilbs;
    #[inline]
    fn add(self, _: UnitMegastilbs) -> Self::Output {
        UnitMegastilbs
    }
}
impl AddAssign<UnitMegastilbs> for UnitMegastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitMegastilbs) {}
}
impl Sub<UnitMegastilbs> for UnitMegastilbs {
    type Output = UnitMegastilbs;
    #[inline]
    fn sub(self, _: UnitMegastilbs) -> Self::Output {
        UnitMegastilbs
    }
}
impl SubAssign<UnitMegastilbs> for UnitMegastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegastilbs) {}
}
pub struct UnitMegastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegastilbsMul {
    #[inline]
    fn clone(&self) -> UnitMegastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitMegastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegastilbsMul> for i8 {
    type Output = Quantity<i8, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for i16 {
    type Output = Quantity<i16, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for i32 {
    type Output = Quantity<i32, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for i64 {
    type Output = Quantity<i64, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for i128 {
    type Output = Quantity<i128, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for isize {
    type Output = Quantity<isize, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for u8 {
    type Output = Quantity<u8, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for u16 {
    type Output = Quantity<u16, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for u32 {
    type Output = Quantity<u32, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for u64 {
    type Output = Quantity<u64, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for u128 {
    type Output = Quantity<u128, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for usize {
    type Output = Quantity<usize, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for f32 {
    type Output = Quantity<f32, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
impl Mul<UnitMegastilbsMul> for f64 {
    type Output = Quantity<f64, UnitMegastilbs>;
    fn mul(self, _: UnitMegastilbsMul) -> Self::Output {
        Quantity::new(self, UnitMegastilbs)
    }
}
pub struct UnitKilostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilostilbs {
    #[inline]
    fn clone(&self) -> UnitKilostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilostilbs {
    #[inline]
    fn eq(&self, other: &UnitKilostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilostilbs {
    fn default() -> Self {
        UnitKilostilbs
    }
}
impl Add<UnitKilostilbs> for UnitKilostilbs {
    type Output = UnitKilostilbs;
    #[inline]
    fn add(self, _: UnitKilostilbs) -> Self::Output {
        UnitKilostilbs
    }
}
impl AddAssign<UnitKilostilbs> for UnitKilostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitKilostilbs) {}
}
impl Sub<UnitKilostilbs> for UnitKilostilbs {
    type Output = UnitKilostilbs;
    #[inline]
    fn sub(self, _: UnitKilostilbs) -> Self::Output {
        UnitKilostilbs
    }
}
impl SubAssign<UnitKilostilbs> for UnitKilostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilostilbs) {}
}
pub struct UnitKilostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilostilbsMul {
    #[inline]
    fn clone(&self) -> UnitKilostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitKilostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilostilbsMul> for i8 {
    type Output = Quantity<i8, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for i16 {
    type Output = Quantity<i16, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for i32 {
    type Output = Quantity<i32, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for i64 {
    type Output = Quantity<i64, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for i128 {
    type Output = Quantity<i128, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for isize {
    type Output = Quantity<isize, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for u8 {
    type Output = Quantity<u8, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for u16 {
    type Output = Quantity<u16, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for u32 {
    type Output = Quantity<u32, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for u64 {
    type Output = Quantity<u64, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for u128 {
    type Output = Quantity<u128, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for usize {
    type Output = Quantity<usize, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for f32 {
    type Output = Quantity<f32, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
impl Mul<UnitKilostilbsMul> for f64 {
    type Output = Quantity<f64, UnitKilostilbs>;
    fn mul(self, _: UnitKilostilbsMul) -> Self::Output {
        Quantity::new(self, UnitKilostilbs)
    }
}
pub struct UnitHectostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectostilbs {
    #[inline]
    fn clone(&self) -> UnitHectostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectostilbs {
    #[inline]
    fn eq(&self, other: &UnitHectostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectostilbs {
    fn default() -> Self {
        UnitHectostilbs
    }
}
impl Add<UnitHectostilbs> for UnitHectostilbs {
    type Output = UnitHectostilbs;
    #[inline]
    fn add(self, _: UnitHectostilbs) -> Self::Output {
        UnitHectostilbs
    }
}
impl AddAssign<UnitHectostilbs> for UnitHectostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitHectostilbs) {}
}
impl Sub<UnitHectostilbs> for UnitHectostilbs {
    type Output = UnitHectostilbs;
    #[inline]
    fn sub(self, _: UnitHectostilbs) -> Self::Output {
        UnitHectostilbs
    }
}
impl SubAssign<UnitHectostilbs> for UnitHectostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectostilbs) {}
}
pub struct UnitHectostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectostilbsMul {
    #[inline]
    fn clone(&self) -> UnitHectostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitHectostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectostilbsMul> for i8 {
    type Output = Quantity<i8, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for i16 {
    type Output = Quantity<i16, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for i32 {
    type Output = Quantity<i32, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for i64 {
    type Output = Quantity<i64, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for i128 {
    type Output = Quantity<i128, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for isize {
    type Output = Quantity<isize, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for u8 {
    type Output = Quantity<u8, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for u16 {
    type Output = Quantity<u16, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for u32 {
    type Output = Quantity<u32, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for u64 {
    type Output = Quantity<u64, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for u128 {
    type Output = Quantity<u128, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for usize {
    type Output = Quantity<usize, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for f32 {
    type Output = Quantity<f32, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
impl Mul<UnitHectostilbsMul> for f64 {
    type Output = Quantity<f64, UnitHectostilbs>;
    fn mul(self, _: UnitHectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitHectostilbs)
    }
}
pub struct UnitDecastilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecastilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecastilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecastilbs {
    #[inline]
    fn clone(&self) -> UnitDecastilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecastilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecastilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecastilbs {
    #[inline]
    fn eq(&self, other: &UnitDecastilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecastilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecastilbs {
    fn default() -> Self {
        UnitDecastilbs
    }
}
impl Add<UnitDecastilbs> for UnitDecastilbs {
    type Output = UnitDecastilbs;
    #[inline]
    fn add(self, _: UnitDecastilbs) -> Self::Output {
        UnitDecastilbs
    }
}
impl AddAssign<UnitDecastilbs> for UnitDecastilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitDecastilbs) {}
}
impl Sub<UnitDecastilbs> for UnitDecastilbs {
    type Output = UnitDecastilbs;
    #[inline]
    fn sub(self, _: UnitDecastilbs) -> Self::Output {
        UnitDecastilbs
    }
}
impl SubAssign<UnitDecastilbs> for UnitDecastilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecastilbs) {}
}
pub struct UnitDecastilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecastilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecastilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecastilbsMul {
    #[inline]
    fn clone(&self) -> UnitDecastilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecastilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecastilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecastilbsMul {
    #[inline]
    fn eq(&self, other: &UnitDecastilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecastilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecastilbsMul> for i8 {
    type Output = Quantity<i8, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for i16 {
    type Output = Quantity<i16, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for i32 {
    type Output = Quantity<i32, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for i64 {
    type Output = Quantity<i64, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for i128 {
    type Output = Quantity<i128, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for isize {
    type Output = Quantity<isize, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for u8 {
    type Output = Quantity<u8, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for u16 {
    type Output = Quantity<u16, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for u32 {
    type Output = Quantity<u32, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for u64 {
    type Output = Quantity<u64, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for u128 {
    type Output = Quantity<u128, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for usize {
    type Output = Quantity<usize, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for f32 {
    type Output = Quantity<f32, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
impl Mul<UnitDecastilbsMul> for f64 {
    type Output = Quantity<f64, UnitDecastilbs>;
    fn mul(self, _: UnitDecastilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecastilbs)
    }
}
pub struct UnitDecistilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecistilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecistilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecistilbs {
    #[inline]
    fn clone(&self) -> UnitDecistilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecistilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecistilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecistilbs {
    #[inline]
    fn eq(&self, other: &UnitDecistilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecistilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecistilbs {
    fn default() -> Self {
        UnitDecistilbs
    }
}
impl Add<UnitDecistilbs> for UnitDecistilbs {
    type Output = UnitDecistilbs;
    #[inline]
    fn add(self, _: UnitDecistilbs) -> Self::Output {
        UnitDecistilbs
    }
}
impl AddAssign<UnitDecistilbs> for UnitDecistilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitDecistilbs) {}
}
impl Sub<UnitDecistilbs> for UnitDecistilbs {
    type Output = UnitDecistilbs;
    #[inline]
    fn sub(self, _: UnitDecistilbs) -> Self::Output {
        UnitDecistilbs
    }
}
impl SubAssign<UnitDecistilbs> for UnitDecistilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecistilbs) {}
}
pub struct UnitDecistilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecistilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecistilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecistilbsMul {
    #[inline]
    fn clone(&self) -> UnitDecistilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecistilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecistilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecistilbsMul {
    #[inline]
    fn eq(&self, other: &UnitDecistilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecistilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecistilbsMul> for i8 {
    type Output = Quantity<i8, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for i16 {
    type Output = Quantity<i16, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for i32 {
    type Output = Quantity<i32, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for i64 {
    type Output = Quantity<i64, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for i128 {
    type Output = Quantity<i128, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for isize {
    type Output = Quantity<isize, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for u8 {
    type Output = Quantity<u8, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for u16 {
    type Output = Quantity<u16, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for u32 {
    type Output = Quantity<u32, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for u64 {
    type Output = Quantity<u64, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for u128 {
    type Output = Quantity<u128, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for usize {
    type Output = Quantity<usize, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for f32 {
    type Output = Quantity<f32, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
impl Mul<UnitDecistilbsMul> for f64 {
    type Output = Quantity<f64, UnitDecistilbs>;
    fn mul(self, _: UnitDecistilbsMul) -> Self::Output {
        Quantity::new(self, UnitDecistilbs)
    }
}
pub struct UnitCentistilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentistilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentistilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentistilbs {
    #[inline]
    fn clone(&self) -> UnitCentistilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentistilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentistilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentistilbs {
    #[inline]
    fn eq(&self, other: &UnitCentistilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentistilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentistilbs {
    fn default() -> Self {
        UnitCentistilbs
    }
}
impl Add<UnitCentistilbs> for UnitCentistilbs {
    type Output = UnitCentistilbs;
    #[inline]
    fn add(self, _: UnitCentistilbs) -> Self::Output {
        UnitCentistilbs
    }
}
impl AddAssign<UnitCentistilbs> for UnitCentistilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitCentistilbs) {}
}
impl Sub<UnitCentistilbs> for UnitCentistilbs {
    type Output = UnitCentistilbs;
    #[inline]
    fn sub(self, _: UnitCentistilbs) -> Self::Output {
        UnitCentistilbs
    }
}
impl SubAssign<UnitCentistilbs> for UnitCentistilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentistilbs) {}
}
pub struct UnitCentistilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentistilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentistilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentistilbsMul {
    #[inline]
    fn clone(&self) -> UnitCentistilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentistilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentistilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentistilbsMul {
    #[inline]
    fn eq(&self, other: &UnitCentistilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentistilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentistilbsMul> for i8 {
    type Output = Quantity<i8, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for i16 {
    type Output = Quantity<i16, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for i32 {
    type Output = Quantity<i32, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for i64 {
    type Output = Quantity<i64, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for i128 {
    type Output = Quantity<i128, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for isize {
    type Output = Quantity<isize, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for u8 {
    type Output = Quantity<u8, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for u16 {
    type Output = Quantity<u16, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for u32 {
    type Output = Quantity<u32, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for u64 {
    type Output = Quantity<u64, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for u128 {
    type Output = Quantity<u128, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for usize {
    type Output = Quantity<usize, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for f32 {
    type Output = Quantity<f32, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
impl Mul<UnitCentistilbsMul> for f64 {
    type Output = Quantity<f64, UnitCentistilbs>;
    fn mul(self, _: UnitCentistilbsMul) -> Self::Output {
        Quantity::new(self, UnitCentistilbs)
    }
}
pub struct UnitMillistilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillistilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillistilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillistilbs {
    #[inline]
    fn clone(&self) -> UnitMillistilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillistilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillistilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillistilbs {
    #[inline]
    fn eq(&self, other: &UnitMillistilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillistilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillistilbs {
    fn default() -> Self {
        UnitMillistilbs
    }
}
impl Add<UnitMillistilbs> for UnitMillistilbs {
    type Output = UnitMillistilbs;
    #[inline]
    fn add(self, _: UnitMillistilbs) -> Self::Output {
        UnitMillistilbs
    }
}
impl AddAssign<UnitMillistilbs> for UnitMillistilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitMillistilbs) {}
}
impl Sub<UnitMillistilbs> for UnitMillistilbs {
    type Output = UnitMillistilbs;
    #[inline]
    fn sub(self, _: UnitMillistilbs) -> Self::Output {
        UnitMillistilbs
    }
}
impl SubAssign<UnitMillistilbs> for UnitMillistilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillistilbs) {}
}
pub struct UnitMillistilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillistilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillistilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillistilbsMul {
    #[inline]
    fn clone(&self) -> UnitMillistilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillistilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillistilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillistilbsMul {
    #[inline]
    fn eq(&self, other: &UnitMillistilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillistilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillistilbsMul> for i8 {
    type Output = Quantity<i8, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for i16 {
    type Output = Quantity<i16, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for i32 {
    type Output = Quantity<i32, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for i64 {
    type Output = Quantity<i64, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for i128 {
    type Output = Quantity<i128, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for isize {
    type Output = Quantity<isize, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for u8 {
    type Output = Quantity<u8, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for u16 {
    type Output = Quantity<u16, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for u32 {
    type Output = Quantity<u32, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for u64 {
    type Output = Quantity<u64, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for u128 {
    type Output = Quantity<u128, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for usize {
    type Output = Quantity<usize, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for f32 {
    type Output = Quantity<f32, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
impl Mul<UnitMillistilbsMul> for f64 {
    type Output = Quantity<f64, UnitMillistilbs>;
    fn mul(self, _: UnitMillistilbsMul) -> Self::Output {
        Quantity::new(self, UnitMillistilbs)
    }
}
pub struct UnitMicrostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrostilbs {
    #[inline]
    fn clone(&self) -> UnitMicrostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrostilbs {
    #[inline]
    fn eq(&self, other: &UnitMicrostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrostilbs {
    fn default() -> Self {
        UnitMicrostilbs
    }
}
impl Add<UnitMicrostilbs> for UnitMicrostilbs {
    type Output = UnitMicrostilbs;
    #[inline]
    fn add(self, _: UnitMicrostilbs) -> Self::Output {
        UnitMicrostilbs
    }
}
impl AddAssign<UnitMicrostilbs> for UnitMicrostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrostilbs) {}
}
impl Sub<UnitMicrostilbs> for UnitMicrostilbs {
    type Output = UnitMicrostilbs;
    #[inline]
    fn sub(self, _: UnitMicrostilbs) -> Self::Output {
        UnitMicrostilbs
    }
}
impl SubAssign<UnitMicrostilbs> for UnitMicrostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrostilbs) {}
}
pub struct UnitMicrostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrostilbsMul {
    #[inline]
    fn clone(&self) -> UnitMicrostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrostilbsMul> for i8 {
    type Output = Quantity<i8, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for i16 {
    type Output = Quantity<i16, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for i32 {
    type Output = Quantity<i32, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for i64 {
    type Output = Quantity<i64, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for i128 {
    type Output = Quantity<i128, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for isize {
    type Output = Quantity<isize, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for u8 {
    type Output = Quantity<u8, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for u16 {
    type Output = Quantity<u16, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for u32 {
    type Output = Quantity<u32, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for u64 {
    type Output = Quantity<u64, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for u128 {
    type Output = Quantity<u128, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for usize {
    type Output = Quantity<usize, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for f32 {
    type Output = Quantity<f32, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
impl Mul<UnitMicrostilbsMul> for f64 {
    type Output = Quantity<f64, UnitMicrostilbs>;
    fn mul(self, _: UnitMicrostilbsMul) -> Self::Output {
        Quantity::new(self, UnitMicrostilbs)
    }
}
pub struct UnitNanostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanostilbs {
    #[inline]
    fn clone(&self) -> UnitNanostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanostilbs {
    #[inline]
    fn eq(&self, other: &UnitNanostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanostilbs {
    fn default() -> Self {
        UnitNanostilbs
    }
}
impl Add<UnitNanostilbs> for UnitNanostilbs {
    type Output = UnitNanostilbs;
    #[inline]
    fn add(self, _: UnitNanostilbs) -> Self::Output {
        UnitNanostilbs
    }
}
impl AddAssign<UnitNanostilbs> for UnitNanostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitNanostilbs) {}
}
impl Sub<UnitNanostilbs> for UnitNanostilbs {
    type Output = UnitNanostilbs;
    #[inline]
    fn sub(self, _: UnitNanostilbs) -> Self::Output {
        UnitNanostilbs
    }
}
impl SubAssign<UnitNanostilbs> for UnitNanostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanostilbs) {}
}
pub struct UnitNanostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanostilbsMul {
    #[inline]
    fn clone(&self) -> UnitNanostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitNanostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanostilbsMul> for i8 {
    type Output = Quantity<i8, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for i16 {
    type Output = Quantity<i16, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for i32 {
    type Output = Quantity<i32, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for i64 {
    type Output = Quantity<i64, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for i128 {
    type Output = Quantity<i128, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for isize {
    type Output = Quantity<isize, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for u8 {
    type Output = Quantity<u8, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for u16 {
    type Output = Quantity<u16, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for u32 {
    type Output = Quantity<u32, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for u64 {
    type Output = Quantity<u64, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for u128 {
    type Output = Quantity<u128, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for usize {
    type Output = Quantity<usize, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for f32 {
    type Output = Quantity<f32, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
impl Mul<UnitNanostilbsMul> for f64 {
    type Output = Quantity<f64, UnitNanostilbs>;
    fn mul(self, _: UnitNanostilbsMul) -> Self::Output {
        Quantity::new(self, UnitNanostilbs)
    }
}
pub struct UnitPicostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicostilbs {
    #[inline]
    fn clone(&self) -> UnitPicostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicostilbs {
    #[inline]
    fn eq(&self, other: &UnitPicostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicostilbs {
    fn default() -> Self {
        UnitPicostilbs
    }
}
impl Add<UnitPicostilbs> for UnitPicostilbs {
    type Output = UnitPicostilbs;
    #[inline]
    fn add(self, _: UnitPicostilbs) -> Self::Output {
        UnitPicostilbs
    }
}
impl AddAssign<UnitPicostilbs> for UnitPicostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitPicostilbs) {}
}
impl Sub<UnitPicostilbs> for UnitPicostilbs {
    type Output = UnitPicostilbs;
    #[inline]
    fn sub(self, _: UnitPicostilbs) -> Self::Output {
        UnitPicostilbs
    }
}
impl SubAssign<UnitPicostilbs> for UnitPicostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicostilbs) {}
}
pub struct UnitPicostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicostilbsMul {
    #[inline]
    fn clone(&self) -> UnitPicostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitPicostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicostilbsMul> for i8 {
    type Output = Quantity<i8, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for i16 {
    type Output = Quantity<i16, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for i32 {
    type Output = Quantity<i32, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for i64 {
    type Output = Quantity<i64, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for i128 {
    type Output = Quantity<i128, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for isize {
    type Output = Quantity<isize, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for u8 {
    type Output = Quantity<u8, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for u16 {
    type Output = Quantity<u16, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for u32 {
    type Output = Quantity<u32, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for u64 {
    type Output = Quantity<u64, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for u128 {
    type Output = Quantity<u128, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for usize {
    type Output = Quantity<usize, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for f32 {
    type Output = Quantity<f32, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
impl Mul<UnitPicostilbsMul> for f64 {
    type Output = Quantity<f64, UnitPicostilbs>;
    fn mul(self, _: UnitPicostilbsMul) -> Self::Output {
        Quantity::new(self, UnitPicostilbs)
    }
}
pub struct UnitFemtostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtostilbs {
    #[inline]
    fn clone(&self) -> UnitFemtostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtostilbs {
    #[inline]
    fn eq(&self, other: &UnitFemtostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtostilbs {
    fn default() -> Self {
        UnitFemtostilbs
    }
}
impl Add<UnitFemtostilbs> for UnitFemtostilbs {
    type Output = UnitFemtostilbs;
    #[inline]
    fn add(self, _: UnitFemtostilbs) -> Self::Output {
        UnitFemtostilbs
    }
}
impl AddAssign<UnitFemtostilbs> for UnitFemtostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtostilbs) {}
}
impl Sub<UnitFemtostilbs> for UnitFemtostilbs {
    type Output = UnitFemtostilbs;
    #[inline]
    fn sub(self, _: UnitFemtostilbs) -> Self::Output {
        UnitFemtostilbs
    }
}
impl SubAssign<UnitFemtostilbs> for UnitFemtostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtostilbs) {}
}
pub struct UnitFemtostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtostilbsMul {
    #[inline]
    fn clone(&self) -> UnitFemtostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtostilbsMul> for i8 {
    type Output = Quantity<i8, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for i16 {
    type Output = Quantity<i16, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for i32 {
    type Output = Quantity<i32, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for i64 {
    type Output = Quantity<i64, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for i128 {
    type Output = Quantity<i128, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for isize {
    type Output = Quantity<isize, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for u8 {
    type Output = Quantity<u8, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for u16 {
    type Output = Quantity<u16, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for u32 {
    type Output = Quantity<u32, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for u64 {
    type Output = Quantity<u64, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for u128 {
    type Output = Quantity<u128, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for usize {
    type Output = Quantity<usize, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for f32 {
    type Output = Quantity<f32, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
impl Mul<UnitFemtostilbsMul> for f64 {
    type Output = Quantity<f64, UnitFemtostilbs>;
    fn mul(self, _: UnitFemtostilbsMul) -> Self::Output {
        Quantity::new(self, UnitFemtostilbs)
    }
}
pub struct UnitAttostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttostilbs {
    #[inline]
    fn clone(&self) -> UnitAttostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttostilbs {
    #[inline]
    fn eq(&self, other: &UnitAttostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttostilbs {
    fn default() -> Self {
        UnitAttostilbs
    }
}
impl Add<UnitAttostilbs> for UnitAttostilbs {
    type Output = UnitAttostilbs;
    #[inline]
    fn add(self, _: UnitAttostilbs) -> Self::Output {
        UnitAttostilbs
    }
}
impl AddAssign<UnitAttostilbs> for UnitAttostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitAttostilbs) {}
}
impl Sub<UnitAttostilbs> for UnitAttostilbs {
    type Output = UnitAttostilbs;
    #[inline]
    fn sub(self, _: UnitAttostilbs) -> Self::Output {
        UnitAttostilbs
    }
}
impl SubAssign<UnitAttostilbs> for UnitAttostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttostilbs) {}
}
pub struct UnitAttostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttostilbsMul {
    #[inline]
    fn clone(&self) -> UnitAttostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitAttostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttostilbsMul> for i8 {
    type Output = Quantity<i8, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for i16 {
    type Output = Quantity<i16, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for i32 {
    type Output = Quantity<i32, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for i64 {
    type Output = Quantity<i64, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for i128 {
    type Output = Quantity<i128, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for isize {
    type Output = Quantity<isize, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for u8 {
    type Output = Quantity<u8, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for u16 {
    type Output = Quantity<u16, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for u32 {
    type Output = Quantity<u32, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for u64 {
    type Output = Quantity<u64, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for u128 {
    type Output = Quantity<u128, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for usize {
    type Output = Quantity<usize, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for f32 {
    type Output = Quantity<f32, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
impl Mul<UnitAttostilbsMul> for f64 {
    type Output = Quantity<f64, UnitAttostilbs>;
    fn mul(self, _: UnitAttostilbsMul) -> Self::Output {
        Quantity::new(self, UnitAttostilbs)
    }
}
pub struct UnitZeptostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptostilbs {
    #[inline]
    fn clone(&self) -> UnitZeptostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptostilbs {
    #[inline]
    fn eq(&self, other: &UnitZeptostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptostilbs {
    fn default() -> Self {
        UnitZeptostilbs
    }
}
impl Add<UnitZeptostilbs> for UnitZeptostilbs {
    type Output = UnitZeptostilbs;
    #[inline]
    fn add(self, _: UnitZeptostilbs) -> Self::Output {
        UnitZeptostilbs
    }
}
impl AddAssign<UnitZeptostilbs> for UnitZeptostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptostilbs) {}
}
impl Sub<UnitZeptostilbs> for UnitZeptostilbs {
    type Output = UnitZeptostilbs;
    #[inline]
    fn sub(self, _: UnitZeptostilbs) -> Self::Output {
        UnitZeptostilbs
    }
}
impl SubAssign<UnitZeptostilbs> for UnitZeptostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptostilbs) {}
}
pub struct UnitZeptostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptostilbsMul {
    #[inline]
    fn clone(&self) -> UnitZeptostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptostilbsMul> for i8 {
    type Output = Quantity<i8, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for i16 {
    type Output = Quantity<i16, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for i32 {
    type Output = Quantity<i32, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for i64 {
    type Output = Quantity<i64, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for i128 {
    type Output = Quantity<i128, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for isize {
    type Output = Quantity<isize, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for u8 {
    type Output = Quantity<u8, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for u16 {
    type Output = Quantity<u16, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for u32 {
    type Output = Quantity<u32, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for u64 {
    type Output = Quantity<u64, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for u128 {
    type Output = Quantity<u128, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for usize {
    type Output = Quantity<usize, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for f32 {
    type Output = Quantity<f32, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
impl Mul<UnitZeptostilbsMul> for f64 {
    type Output = Quantity<f64, UnitZeptostilbs>;
    fn mul(self, _: UnitZeptostilbsMul) -> Self::Output {
        Quantity::new(self, UnitZeptostilbs)
    }
}
pub struct UnitYoctostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctostilbs {
    #[inline]
    fn clone(&self) -> UnitYoctostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctostilbs {
    #[inline]
    fn eq(&self, other: &UnitYoctostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctostilbs {
    fn default() -> Self {
        UnitYoctostilbs
    }
}
impl Add<UnitYoctostilbs> for UnitYoctostilbs {
    type Output = UnitYoctostilbs;
    #[inline]
    fn add(self, _: UnitYoctostilbs) -> Self::Output {
        UnitYoctostilbs
    }
}
impl AddAssign<UnitYoctostilbs> for UnitYoctostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctostilbs) {}
}
impl Sub<UnitYoctostilbs> for UnitYoctostilbs {
    type Output = UnitYoctostilbs;
    #[inline]
    fn sub(self, _: UnitYoctostilbs) -> Self::Output {
        UnitYoctostilbs
    }
}
impl SubAssign<UnitYoctostilbs> for UnitYoctostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctostilbs) {}
}
pub struct UnitYoctostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctostilbsMul {
    #[inline]
    fn clone(&self) -> UnitYoctostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctostilbsMul> for i8 {
    type Output = Quantity<i8, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for i16 {
    type Output = Quantity<i16, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for i32 {
    type Output = Quantity<i32, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for i64 {
    type Output = Quantity<i64, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for i128 {
    type Output = Quantity<i128, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for isize {
    type Output = Quantity<isize, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for u8 {
    type Output = Quantity<u8, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for u16 {
    type Output = Quantity<u16, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for u32 {
    type Output = Quantity<u32, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for u64 {
    type Output = Quantity<u64, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for u128 {
    type Output = Quantity<u128, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for usize {
    type Output = Quantity<usize, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for f32 {
    type Output = Quantity<f32, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
impl Mul<UnitYoctostilbsMul> for f64 {
    type Output = Quantity<f64, UnitYoctostilbs>;
    fn mul(self, _: UnitYoctostilbsMul) -> Self::Output {
        Quantity::new(self, UnitYoctostilbs)
    }
}
pub struct UnitRontostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontostilbs {
    #[inline]
    fn clone(&self) -> UnitRontostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontostilbs {
    #[inline]
    fn eq(&self, other: &UnitRontostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontostilbs {
    fn default() -> Self {
        UnitRontostilbs
    }
}
impl Add<UnitRontostilbs> for UnitRontostilbs {
    type Output = UnitRontostilbs;
    #[inline]
    fn add(self, _: UnitRontostilbs) -> Self::Output {
        UnitRontostilbs
    }
}
impl AddAssign<UnitRontostilbs> for UnitRontostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitRontostilbs) {}
}
impl Sub<UnitRontostilbs> for UnitRontostilbs {
    type Output = UnitRontostilbs;
    #[inline]
    fn sub(self, _: UnitRontostilbs) -> Self::Output {
        UnitRontostilbs
    }
}
impl SubAssign<UnitRontostilbs> for UnitRontostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontostilbs) {}
}
pub struct UnitRontostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontostilbsMul {
    #[inline]
    fn clone(&self) -> UnitRontostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitRontostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontostilbsMul> for i8 {
    type Output = Quantity<i8, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for i16 {
    type Output = Quantity<i16, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for i32 {
    type Output = Quantity<i32, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for i64 {
    type Output = Quantity<i64, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for i128 {
    type Output = Quantity<i128, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for isize {
    type Output = Quantity<isize, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for u8 {
    type Output = Quantity<u8, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for u16 {
    type Output = Quantity<u16, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for u32 {
    type Output = Quantity<u32, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for u64 {
    type Output = Quantity<u64, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for u128 {
    type Output = Quantity<u128, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for usize {
    type Output = Quantity<usize, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for f32 {
    type Output = Quantity<f32, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
impl Mul<UnitRontostilbsMul> for f64 {
    type Output = Quantity<f64, UnitRontostilbs>;
    fn mul(self, _: UnitRontostilbsMul) -> Self::Output {
        Quantity::new(self, UnitRontostilbs)
    }
}
pub struct UnitQuectostilbs;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectostilbs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectostilbs")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectostilbs {
    #[inline]
    fn clone(&self) -> UnitQuectostilbs {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectostilbs {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectostilbs {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectostilbs {
    #[inline]
    fn eq(&self, other: &UnitQuectostilbs) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectostilbs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectostilbs {
    fn default() -> Self {
        UnitQuectostilbs
    }
}
impl Add<UnitQuectostilbs> for UnitQuectostilbs {
    type Output = UnitQuectostilbs;
    #[inline]
    fn add(self, _: UnitQuectostilbs) -> Self::Output {
        UnitQuectostilbs
    }
}
impl AddAssign<UnitQuectostilbs> for UnitQuectostilbs {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectostilbs) {}
}
impl Sub<UnitQuectostilbs> for UnitQuectostilbs {
    type Output = UnitQuectostilbs;
    #[inline]
    fn sub(self, _: UnitQuectostilbs) -> Self::Output {
        UnitQuectostilbs
    }
}
impl SubAssign<UnitQuectostilbs> for UnitQuectostilbs {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectostilbs) {}
}
pub struct UnitQuectostilbsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectostilbsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectostilbsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectostilbsMul {
    #[inline]
    fn clone(&self) -> UnitQuectostilbsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectostilbsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectostilbsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectostilbsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectostilbsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectostilbsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectostilbsMul> for i8 {
    type Output = Quantity<i8, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for i16 {
    type Output = Quantity<i16, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for i32 {
    type Output = Quantity<i32, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for i64 {
    type Output = Quantity<i64, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for i128 {
    type Output = Quantity<i128, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for isize {
    type Output = Quantity<isize, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for u8 {
    type Output = Quantity<u8, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for u16 {
    type Output = Quantity<u16, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for u32 {
    type Output = Quantity<u32, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for u64 {
    type Output = Quantity<u64, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for u128 {
    type Output = Quantity<u128, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for usize {
    type Output = Quantity<usize, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for f32 {
    type Output = Quantity<f32, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
impl Mul<UnitQuectostilbsMul> for f64 {
    type Output = Quantity<f64, UnitQuectostilbs>;
    fn mul(self, _: UnitQuectostilbsMul) -> Self::Output {
        Quantity::new(self, UnitQuectostilbs)
    }
}
pub type Stilbs<T> = Quantity<T, UnitStilbs>;
#[allow(non_upper_case_globals)]
pub static Stilbs: UnitStilbsMul = UnitStilbsMul;
pub type Quettastilbs<T> = Quantity<T, UnitQuettastilbs>;
#[allow(non_upper_case_globals)]
pub static Quettastilbs: UnitQuettastilbsMul = UnitQuettastilbsMul;
pub type Ronnastilbs<T> = Quantity<T, UnitRonnastilbs>;
#[allow(non_upper_case_globals)]
pub static Ronnastilbs: UnitRonnastilbsMul = UnitRonnastilbsMul;
pub type Yottastilbs<T> = Quantity<T, UnitYottastilbs>;
#[allow(non_upper_case_globals)]
pub static Yottastilbs: UnitYottastilbsMul = UnitYottastilbsMul;
pub type Zettastilbs<T> = Quantity<T, UnitZettastilbs>;
#[allow(non_upper_case_globals)]
pub static Zettastilbs: UnitZettastilbsMul = UnitZettastilbsMul;
pub type Exastilbs<T> = Quantity<T, UnitExastilbs>;
#[allow(non_upper_case_globals)]
pub static Exastilbs: UnitExastilbsMul = UnitExastilbsMul;
pub type Petastilbs<T> = Quantity<T, UnitPetastilbs>;
#[allow(non_upper_case_globals)]
pub static Petastilbs: UnitPetastilbsMul = UnitPetastilbsMul;
pub type Terastilbs<T> = Quantity<T, UnitTerastilbs>;
#[allow(non_upper_case_globals)]
pub static Terastilbs: UnitTerastilbsMul = UnitTerastilbsMul;
pub type Gigastilbs<T> = Quantity<T, UnitGigastilbs>;
#[allow(non_upper_case_globals)]
pub static Gigastilbs: UnitGigastilbsMul = UnitGigastilbsMul;
pub type Megastilbs<T> = Quantity<T, UnitMegastilbs>;
#[allow(non_upper_case_globals)]
pub static Megastilbs: UnitMegastilbsMul = UnitMegastilbsMul;
pub type Kilostilbs<T> = Quantity<T, UnitKilostilbs>;
#[allow(non_upper_case_globals)]
pub static Kilostilbs: UnitKilostilbsMul = UnitKilostilbsMul;
pub type Hectostilbs<T> = Quantity<T, UnitHectostilbs>;
#[allow(non_upper_case_globals)]
pub static Hectostilbs: UnitHectostilbsMul = UnitHectostilbsMul;
pub type Decastilbs<T> = Quantity<T, UnitDecastilbs>;
#[allow(non_upper_case_globals)]
pub static Decastilbs: UnitDecastilbsMul = UnitDecastilbsMul;
pub type Decistilbs<T> = Quantity<T, UnitDecistilbs>;
#[allow(non_upper_case_globals)]
pub static Decistilbs: UnitDecistilbsMul = UnitDecistilbsMul;
pub type Centistilbs<T> = Quantity<T, UnitCentistilbs>;
#[allow(non_upper_case_globals)]
pub static Centistilbs: UnitCentistilbsMul = UnitCentistilbsMul;
pub type Millistilbs<T> = Quantity<T, UnitMillistilbs>;
#[allow(non_upper_case_globals)]
pub static Millistilbs: UnitMillistilbsMul = UnitMillistilbsMul;
pub type Microstilbs<T> = Quantity<T, UnitMicrostilbs>;
#[allow(non_upper_case_globals)]
pub static Microstilbs: UnitMicrostilbsMul = UnitMicrostilbsMul;
pub type Nanostilbs<T> = Quantity<T, UnitNanostilbs>;
#[allow(non_upper_case_globals)]
pub static Nanostilbs: UnitNanostilbsMul = UnitNanostilbsMul;
pub type Picostilbs<T> = Quantity<T, UnitPicostilbs>;
#[allow(non_upper_case_globals)]
pub static Picostilbs: UnitPicostilbsMul = UnitPicostilbsMul;
pub type Femtostilbs<T> = Quantity<T, UnitFemtostilbs>;
#[allow(non_upper_case_globals)]
pub static Femtostilbs: UnitFemtostilbsMul = UnitFemtostilbsMul;
pub type Attostilbs<T> = Quantity<T, UnitAttostilbs>;
#[allow(non_upper_case_globals)]
pub static Attostilbs: UnitAttostilbsMul = UnitAttostilbsMul;
pub type Zeptostilbs<T> = Quantity<T, UnitZeptostilbs>;
#[allow(non_upper_case_globals)]
pub static Zeptostilbs: UnitZeptostilbsMul = UnitZeptostilbsMul;
pub type Yoctostilbs<T> = Quantity<T, UnitYoctostilbs>;
#[allow(non_upper_case_globals)]
pub static Yoctostilbs: UnitYoctostilbsMul = UnitYoctostilbsMul;
pub type Rontostilbs<T> = Quantity<T, UnitRontostilbs>;
#[allow(non_upper_case_globals)]
pub static Rontostilbs: UnitRontostilbsMul = UnitRontostilbsMul;
pub type Quectostilbs<T> = Quantity<T, UnitQuectostilbs>;
#[allow(non_upper_case_globals)]
pub static Quectostilbs: UnitQuectostilbsMul = UnitQuectostilbsMul;
pub struct UnitPhots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPhots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPhots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPhots {
    #[inline]
    fn clone(&self) -> UnitPhots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPhots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPhots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPhots {
    #[inline]
    fn eq(&self, other: &UnitPhots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPhots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPhots {
    fn default() -> Self {
        UnitPhots
    }
}
impl Add<UnitPhots> for UnitPhots {
    type Output = UnitPhots;
    #[inline]
    fn add(self, _: UnitPhots) -> Self::Output {
        UnitPhots
    }
}
impl AddAssign<UnitPhots> for UnitPhots {
    #[inline]
    fn add_assign(&mut self, _: UnitPhots) {}
}
impl Sub<UnitPhots> for UnitPhots {
    type Output = UnitPhots;
    #[inline]
    fn sub(self, _: UnitPhots) -> Self::Output {
        UnitPhots
    }
}
impl SubAssign<UnitPhots> for UnitPhots {
    #[inline]
    fn sub_assign(&mut self, _: UnitPhots) {}
}
pub struct UnitPhotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPhotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPhotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPhotsMul {
    #[inline]
    fn clone(&self) -> UnitPhotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPhotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPhotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPhotsMul {
    #[inline]
    fn eq(&self, other: &UnitPhotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPhotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPhotsMul> for i8 {
    type Output = Quantity<i8, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for i16 {
    type Output = Quantity<i16, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for i32 {
    type Output = Quantity<i32, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for i64 {
    type Output = Quantity<i64, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for i128 {
    type Output = Quantity<i128, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for isize {
    type Output = Quantity<isize, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for u8 {
    type Output = Quantity<u8, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for u16 {
    type Output = Quantity<u16, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for u32 {
    type Output = Quantity<u32, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for u64 {
    type Output = Quantity<u64, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for u128 {
    type Output = Quantity<u128, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for usize {
    type Output = Quantity<usize, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for f32 {
    type Output = Quantity<f32, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
impl Mul<UnitPhotsMul> for f64 {
    type Output = Quantity<f64, UnitPhots>;
    fn mul(self, _: UnitPhotsMul) -> Self::Output {
        Quantity::new(self, UnitPhots)
    }
}
pub struct UnitQuettaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaphots {
    #[inline]
    fn clone(&self) -> UnitQuettaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaphots {
    #[inline]
    fn eq(&self, other: &UnitQuettaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaphots {
    fn default() -> Self {
        UnitQuettaphots
    }
}
impl Add<UnitQuettaphots> for UnitQuettaphots {
    type Output = UnitQuettaphots;
    #[inline]
    fn add(self, _: UnitQuettaphots) -> Self::Output {
        UnitQuettaphots
    }
}
impl AddAssign<UnitQuettaphots> for UnitQuettaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaphots) {}
}
impl Sub<UnitQuettaphots> for UnitQuettaphots {
    type Output = UnitQuettaphots;
    #[inline]
    fn sub(self, _: UnitQuettaphots) -> Self::Output {
        UnitQuettaphots
    }
}
impl SubAssign<UnitQuettaphots> for UnitQuettaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaphots) {}
}
pub struct UnitQuettaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaphotsMul {
    #[inline]
    fn clone(&self) -> UnitQuettaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaphotsMul> for i8 {
    type Output = Quantity<i8, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for i16 {
    type Output = Quantity<i16, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for i32 {
    type Output = Quantity<i32, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for i64 {
    type Output = Quantity<i64, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for i128 {
    type Output = Quantity<i128, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for isize {
    type Output = Quantity<isize, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for u8 {
    type Output = Quantity<u8, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for u16 {
    type Output = Quantity<u16, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for u32 {
    type Output = Quantity<u32, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for u64 {
    type Output = Quantity<u64, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for u128 {
    type Output = Quantity<u128, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for usize {
    type Output = Quantity<usize, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for f32 {
    type Output = Quantity<f32, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
impl Mul<UnitQuettaphotsMul> for f64 {
    type Output = Quantity<f64, UnitQuettaphots>;
    fn mul(self, _: UnitQuettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaphots)
    }
}
pub struct UnitRonnaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaphots {
    #[inline]
    fn clone(&self) -> UnitRonnaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaphots {
    #[inline]
    fn eq(&self, other: &UnitRonnaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaphots {
    fn default() -> Self {
        UnitRonnaphots
    }
}
impl Add<UnitRonnaphots> for UnitRonnaphots {
    type Output = UnitRonnaphots;
    #[inline]
    fn add(self, _: UnitRonnaphots) -> Self::Output {
        UnitRonnaphots
    }
}
impl AddAssign<UnitRonnaphots> for UnitRonnaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaphots) {}
}
impl Sub<UnitRonnaphots> for UnitRonnaphots {
    type Output = UnitRonnaphots;
    #[inline]
    fn sub(self, _: UnitRonnaphots) -> Self::Output {
        UnitRonnaphots
    }
}
impl SubAssign<UnitRonnaphots> for UnitRonnaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaphots) {}
}
pub struct UnitRonnaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaphotsMul {
    #[inline]
    fn clone(&self) -> UnitRonnaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaphotsMul> for i8 {
    type Output = Quantity<i8, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for i16 {
    type Output = Quantity<i16, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for i32 {
    type Output = Quantity<i32, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for i64 {
    type Output = Quantity<i64, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for i128 {
    type Output = Quantity<i128, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for isize {
    type Output = Quantity<isize, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for u8 {
    type Output = Quantity<u8, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for u16 {
    type Output = Quantity<u16, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for u32 {
    type Output = Quantity<u32, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for u64 {
    type Output = Quantity<u64, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for u128 {
    type Output = Quantity<u128, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for usize {
    type Output = Quantity<usize, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for f32 {
    type Output = Quantity<f32, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
impl Mul<UnitRonnaphotsMul> for f64 {
    type Output = Quantity<f64, UnitRonnaphots>;
    fn mul(self, _: UnitRonnaphotsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaphots)
    }
}
pub struct UnitYottaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaphots {
    #[inline]
    fn clone(&self) -> UnitYottaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaphots {
    #[inline]
    fn eq(&self, other: &UnitYottaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaphots {
    fn default() -> Self {
        UnitYottaphots
    }
}
impl Add<UnitYottaphots> for UnitYottaphots {
    type Output = UnitYottaphots;
    #[inline]
    fn add(self, _: UnitYottaphots) -> Self::Output {
        UnitYottaphots
    }
}
impl AddAssign<UnitYottaphots> for UnitYottaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaphots) {}
}
impl Sub<UnitYottaphots> for UnitYottaphots {
    type Output = UnitYottaphots;
    #[inline]
    fn sub(self, _: UnitYottaphots) -> Self::Output {
        UnitYottaphots
    }
}
impl SubAssign<UnitYottaphots> for UnitYottaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaphots) {}
}
pub struct UnitYottaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaphotsMul {
    #[inline]
    fn clone(&self) -> UnitYottaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitYottaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaphotsMul> for i8 {
    type Output = Quantity<i8, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for i16 {
    type Output = Quantity<i16, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for i32 {
    type Output = Quantity<i32, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for i64 {
    type Output = Quantity<i64, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for i128 {
    type Output = Quantity<i128, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for isize {
    type Output = Quantity<isize, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for u8 {
    type Output = Quantity<u8, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for u16 {
    type Output = Quantity<u16, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for u32 {
    type Output = Quantity<u32, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for u64 {
    type Output = Quantity<u64, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for u128 {
    type Output = Quantity<u128, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for usize {
    type Output = Quantity<usize, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for f32 {
    type Output = Quantity<f32, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
impl Mul<UnitYottaphotsMul> for f64 {
    type Output = Quantity<f64, UnitYottaphots>;
    fn mul(self, _: UnitYottaphotsMul) -> Self::Output {
        Quantity::new(self, UnitYottaphots)
    }
}
pub struct UnitZettaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaphots {
    #[inline]
    fn clone(&self) -> UnitZettaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaphots {
    #[inline]
    fn eq(&self, other: &UnitZettaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaphots {
    fn default() -> Self {
        UnitZettaphots
    }
}
impl Add<UnitZettaphots> for UnitZettaphots {
    type Output = UnitZettaphots;
    #[inline]
    fn add(self, _: UnitZettaphots) -> Self::Output {
        UnitZettaphots
    }
}
impl AddAssign<UnitZettaphots> for UnitZettaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaphots) {}
}
impl Sub<UnitZettaphots> for UnitZettaphots {
    type Output = UnitZettaphots;
    #[inline]
    fn sub(self, _: UnitZettaphots) -> Self::Output {
        UnitZettaphots
    }
}
impl SubAssign<UnitZettaphots> for UnitZettaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaphots) {}
}
pub struct UnitZettaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaphotsMul {
    #[inline]
    fn clone(&self) -> UnitZettaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitZettaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaphotsMul> for i8 {
    type Output = Quantity<i8, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for i16 {
    type Output = Quantity<i16, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for i32 {
    type Output = Quantity<i32, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for i64 {
    type Output = Quantity<i64, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for i128 {
    type Output = Quantity<i128, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for isize {
    type Output = Quantity<isize, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for u8 {
    type Output = Quantity<u8, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for u16 {
    type Output = Quantity<u16, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for u32 {
    type Output = Quantity<u32, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for u64 {
    type Output = Quantity<u64, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for u128 {
    type Output = Quantity<u128, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for usize {
    type Output = Quantity<usize, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for f32 {
    type Output = Quantity<f32, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
impl Mul<UnitZettaphotsMul> for f64 {
    type Output = Quantity<f64, UnitZettaphots>;
    fn mul(self, _: UnitZettaphotsMul) -> Self::Output {
        Quantity::new(self, UnitZettaphots)
    }
}
pub struct UnitExaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaphots {
    #[inline]
    fn clone(&self) -> UnitExaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaphots {
    #[inline]
    fn eq(&self, other: &UnitExaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaphots {
    fn default() -> Self {
        UnitExaphots
    }
}
impl Add<UnitExaphots> for UnitExaphots {
    type Output = UnitExaphots;
    #[inline]
    fn add(self, _: UnitExaphots) -> Self::Output {
        UnitExaphots
    }
}
impl AddAssign<UnitExaphots> for UnitExaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitExaphots) {}
}
impl Sub<UnitExaphots> for UnitExaphots {
    type Output = UnitExaphots;
    #[inline]
    fn sub(self, _: UnitExaphots) -> Self::Output {
        UnitExaphots
    }
}
impl SubAssign<UnitExaphots> for UnitExaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaphots) {}
}
pub struct UnitExaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaphotsMul {
    #[inline]
    fn clone(&self) -> UnitExaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitExaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaphotsMul> for i8 {
    type Output = Quantity<i8, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for i16 {
    type Output = Quantity<i16, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for i32 {
    type Output = Quantity<i32, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for i64 {
    type Output = Quantity<i64, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for i128 {
    type Output = Quantity<i128, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for isize {
    type Output = Quantity<isize, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for u8 {
    type Output = Quantity<u8, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for u16 {
    type Output = Quantity<u16, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for u32 {
    type Output = Quantity<u32, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for u64 {
    type Output = Quantity<u64, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for u128 {
    type Output = Quantity<u128, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for usize {
    type Output = Quantity<usize, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for f32 {
    type Output = Quantity<f32, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
impl Mul<UnitExaphotsMul> for f64 {
    type Output = Quantity<f64, UnitExaphots>;
    fn mul(self, _: UnitExaphotsMul) -> Self::Output {
        Quantity::new(self, UnitExaphots)
    }
}
pub struct UnitPetaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaphots {
    #[inline]
    fn clone(&self) -> UnitPetaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaphots {
    #[inline]
    fn eq(&self, other: &UnitPetaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaphots {
    fn default() -> Self {
        UnitPetaphots
    }
}
impl Add<UnitPetaphots> for UnitPetaphots {
    type Output = UnitPetaphots;
    #[inline]
    fn add(self, _: UnitPetaphots) -> Self::Output {
        UnitPetaphots
    }
}
impl AddAssign<UnitPetaphots> for UnitPetaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaphots) {}
}
impl Sub<UnitPetaphots> for UnitPetaphots {
    type Output = UnitPetaphots;
    #[inline]
    fn sub(self, _: UnitPetaphots) -> Self::Output {
        UnitPetaphots
    }
}
impl SubAssign<UnitPetaphots> for UnitPetaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaphots) {}
}
pub struct UnitPetaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaphotsMul {
    #[inline]
    fn clone(&self) -> UnitPetaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitPetaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaphotsMul> for i8 {
    type Output = Quantity<i8, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for i16 {
    type Output = Quantity<i16, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for i32 {
    type Output = Quantity<i32, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for i64 {
    type Output = Quantity<i64, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for i128 {
    type Output = Quantity<i128, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for isize {
    type Output = Quantity<isize, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for u8 {
    type Output = Quantity<u8, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for u16 {
    type Output = Quantity<u16, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for u32 {
    type Output = Quantity<u32, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for u64 {
    type Output = Quantity<u64, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for u128 {
    type Output = Quantity<u128, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for usize {
    type Output = Quantity<usize, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for f32 {
    type Output = Quantity<f32, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
impl Mul<UnitPetaphotsMul> for f64 {
    type Output = Quantity<f64, UnitPetaphots>;
    fn mul(self, _: UnitPetaphotsMul) -> Self::Output {
        Quantity::new(self, UnitPetaphots)
    }
}
pub struct UnitTeraphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraphots {
    #[inline]
    fn clone(&self) -> UnitTeraphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraphots {
    #[inline]
    fn eq(&self, other: &UnitTeraphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraphots {
    fn default() -> Self {
        UnitTeraphots
    }
}
impl Add<UnitTeraphots> for UnitTeraphots {
    type Output = UnitTeraphots;
    #[inline]
    fn add(self, _: UnitTeraphots) -> Self::Output {
        UnitTeraphots
    }
}
impl AddAssign<UnitTeraphots> for UnitTeraphots {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraphots) {}
}
impl Sub<UnitTeraphots> for UnitTeraphots {
    type Output = UnitTeraphots;
    #[inline]
    fn sub(self, _: UnitTeraphots) -> Self::Output {
        UnitTeraphots
    }
}
impl SubAssign<UnitTeraphots> for UnitTeraphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraphots) {}
}
pub struct UnitTeraphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraphotsMul {
    #[inline]
    fn clone(&self) -> UnitTeraphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraphotsMul {
    #[inline]
    fn eq(&self, other: &UnitTeraphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraphotsMul> for i8 {
    type Output = Quantity<i8, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for i16 {
    type Output = Quantity<i16, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for i32 {
    type Output = Quantity<i32, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for i64 {
    type Output = Quantity<i64, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for i128 {
    type Output = Quantity<i128, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for isize {
    type Output = Quantity<isize, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for u8 {
    type Output = Quantity<u8, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for u16 {
    type Output = Quantity<u16, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for u32 {
    type Output = Quantity<u32, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for u64 {
    type Output = Quantity<u64, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for u128 {
    type Output = Quantity<u128, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for usize {
    type Output = Quantity<usize, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for f32 {
    type Output = Quantity<f32, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
impl Mul<UnitTeraphotsMul> for f64 {
    type Output = Quantity<f64, UnitTeraphots>;
    fn mul(self, _: UnitTeraphotsMul) -> Self::Output {
        Quantity::new(self, UnitTeraphots)
    }
}
pub struct UnitGigaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaphots {
    #[inline]
    fn clone(&self) -> UnitGigaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaphots {
    #[inline]
    fn eq(&self, other: &UnitGigaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaphots {
    fn default() -> Self {
        UnitGigaphots
    }
}
impl Add<UnitGigaphots> for UnitGigaphots {
    type Output = UnitGigaphots;
    #[inline]
    fn add(self, _: UnitGigaphots) -> Self::Output {
        UnitGigaphots
    }
}
impl AddAssign<UnitGigaphots> for UnitGigaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaphots) {}
}
impl Sub<UnitGigaphots> for UnitGigaphots {
    type Output = UnitGigaphots;
    #[inline]
    fn sub(self, _: UnitGigaphots) -> Self::Output {
        UnitGigaphots
    }
}
impl SubAssign<UnitGigaphots> for UnitGigaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaphots) {}
}
pub struct UnitGigaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaphotsMul {
    #[inline]
    fn clone(&self) -> UnitGigaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitGigaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaphotsMul> for i8 {
    type Output = Quantity<i8, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for i16 {
    type Output = Quantity<i16, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for i32 {
    type Output = Quantity<i32, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for i64 {
    type Output = Quantity<i64, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for i128 {
    type Output = Quantity<i128, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for isize {
    type Output = Quantity<isize, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for u8 {
    type Output = Quantity<u8, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for u16 {
    type Output = Quantity<u16, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for u32 {
    type Output = Quantity<u32, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for u64 {
    type Output = Quantity<u64, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for u128 {
    type Output = Quantity<u128, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for usize {
    type Output = Quantity<usize, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for f32 {
    type Output = Quantity<f32, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
impl Mul<UnitGigaphotsMul> for f64 {
    type Output = Quantity<f64, UnitGigaphots>;
    fn mul(self, _: UnitGigaphotsMul) -> Self::Output {
        Quantity::new(self, UnitGigaphots)
    }
}
pub struct UnitMegaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaphots {
    #[inline]
    fn clone(&self) -> UnitMegaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaphots {
    #[inline]
    fn eq(&self, other: &UnitMegaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaphots {
    fn default() -> Self {
        UnitMegaphots
    }
}
impl Add<UnitMegaphots> for UnitMegaphots {
    type Output = UnitMegaphots;
    #[inline]
    fn add(self, _: UnitMegaphots) -> Self::Output {
        UnitMegaphots
    }
}
impl AddAssign<UnitMegaphots> for UnitMegaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaphots) {}
}
impl Sub<UnitMegaphots> for UnitMegaphots {
    type Output = UnitMegaphots;
    #[inline]
    fn sub(self, _: UnitMegaphots) -> Self::Output {
        UnitMegaphots
    }
}
impl SubAssign<UnitMegaphots> for UnitMegaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaphots) {}
}
pub struct UnitMegaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaphotsMul {
    #[inline]
    fn clone(&self) -> UnitMegaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitMegaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaphotsMul> for i8 {
    type Output = Quantity<i8, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for i16 {
    type Output = Quantity<i16, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for i32 {
    type Output = Quantity<i32, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for i64 {
    type Output = Quantity<i64, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for i128 {
    type Output = Quantity<i128, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for isize {
    type Output = Quantity<isize, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for u8 {
    type Output = Quantity<u8, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for u16 {
    type Output = Quantity<u16, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for u32 {
    type Output = Quantity<u32, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for u64 {
    type Output = Quantity<u64, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for u128 {
    type Output = Quantity<u128, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for usize {
    type Output = Quantity<usize, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for f32 {
    type Output = Quantity<f32, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
impl Mul<UnitMegaphotsMul> for f64 {
    type Output = Quantity<f64, UnitMegaphots>;
    fn mul(self, _: UnitMegaphotsMul) -> Self::Output {
        Quantity::new(self, UnitMegaphots)
    }
}
pub struct UnitKilophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilophots {
    #[inline]
    fn clone(&self) -> UnitKilophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilophots {
    #[inline]
    fn eq(&self, other: &UnitKilophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilophots {
    fn default() -> Self {
        UnitKilophots
    }
}
impl Add<UnitKilophots> for UnitKilophots {
    type Output = UnitKilophots;
    #[inline]
    fn add(self, _: UnitKilophots) -> Self::Output {
        UnitKilophots
    }
}
impl AddAssign<UnitKilophots> for UnitKilophots {
    #[inline]
    fn add_assign(&mut self, _: UnitKilophots) {}
}
impl Sub<UnitKilophots> for UnitKilophots {
    type Output = UnitKilophots;
    #[inline]
    fn sub(self, _: UnitKilophots) -> Self::Output {
        UnitKilophots
    }
}
impl SubAssign<UnitKilophots> for UnitKilophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilophots) {}
}
pub struct UnitKilophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilophotsMul {
    #[inline]
    fn clone(&self) -> UnitKilophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilophotsMul {
    #[inline]
    fn eq(&self, other: &UnitKilophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilophotsMul> for i8 {
    type Output = Quantity<i8, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for i16 {
    type Output = Quantity<i16, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for i32 {
    type Output = Quantity<i32, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for i64 {
    type Output = Quantity<i64, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for i128 {
    type Output = Quantity<i128, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for isize {
    type Output = Quantity<isize, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for u8 {
    type Output = Quantity<u8, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for u16 {
    type Output = Quantity<u16, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for u32 {
    type Output = Quantity<u32, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for u64 {
    type Output = Quantity<u64, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for u128 {
    type Output = Quantity<u128, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for usize {
    type Output = Quantity<usize, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for f32 {
    type Output = Quantity<f32, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
impl Mul<UnitKilophotsMul> for f64 {
    type Output = Quantity<f64, UnitKilophots>;
    fn mul(self, _: UnitKilophotsMul) -> Self::Output {
        Quantity::new(self, UnitKilophots)
    }
}
pub struct UnitHectophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectophots {
    #[inline]
    fn clone(&self) -> UnitHectophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectophots {
    #[inline]
    fn eq(&self, other: &UnitHectophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectophots {
    fn default() -> Self {
        UnitHectophots
    }
}
impl Add<UnitHectophots> for UnitHectophots {
    type Output = UnitHectophots;
    #[inline]
    fn add(self, _: UnitHectophots) -> Self::Output {
        UnitHectophots
    }
}
impl AddAssign<UnitHectophots> for UnitHectophots {
    #[inline]
    fn add_assign(&mut self, _: UnitHectophots) {}
}
impl Sub<UnitHectophots> for UnitHectophots {
    type Output = UnitHectophots;
    #[inline]
    fn sub(self, _: UnitHectophots) -> Self::Output {
        UnitHectophots
    }
}
impl SubAssign<UnitHectophots> for UnitHectophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectophots) {}
}
pub struct UnitHectophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectophotsMul {
    #[inline]
    fn clone(&self) -> UnitHectophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectophotsMul {
    #[inline]
    fn eq(&self, other: &UnitHectophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectophotsMul> for i8 {
    type Output = Quantity<i8, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for i16 {
    type Output = Quantity<i16, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for i32 {
    type Output = Quantity<i32, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for i64 {
    type Output = Quantity<i64, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for i128 {
    type Output = Quantity<i128, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for isize {
    type Output = Quantity<isize, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for u8 {
    type Output = Quantity<u8, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for u16 {
    type Output = Quantity<u16, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for u32 {
    type Output = Quantity<u32, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for u64 {
    type Output = Quantity<u64, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for u128 {
    type Output = Quantity<u128, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for usize {
    type Output = Quantity<usize, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for f32 {
    type Output = Quantity<f32, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
impl Mul<UnitHectophotsMul> for f64 {
    type Output = Quantity<f64, UnitHectophots>;
    fn mul(self, _: UnitHectophotsMul) -> Self::Output {
        Quantity::new(self, UnitHectophots)
    }
}
pub struct UnitDecaphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaphots {
    #[inline]
    fn clone(&self) -> UnitDecaphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaphots {
    #[inline]
    fn eq(&self, other: &UnitDecaphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaphots {
    fn default() -> Self {
        UnitDecaphots
    }
}
impl Add<UnitDecaphots> for UnitDecaphots {
    type Output = UnitDecaphots;
    #[inline]
    fn add(self, _: UnitDecaphots) -> Self::Output {
        UnitDecaphots
    }
}
impl AddAssign<UnitDecaphots> for UnitDecaphots {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaphots) {}
}
impl Sub<UnitDecaphots> for UnitDecaphots {
    type Output = UnitDecaphots;
    #[inline]
    fn sub(self, _: UnitDecaphots) -> Self::Output {
        UnitDecaphots
    }
}
impl SubAssign<UnitDecaphots> for UnitDecaphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaphots) {}
}
pub struct UnitDecaphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaphotsMul {
    #[inline]
    fn clone(&self) -> UnitDecaphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaphotsMul {
    #[inline]
    fn eq(&self, other: &UnitDecaphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaphotsMul> for i8 {
    type Output = Quantity<i8, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for i16 {
    type Output = Quantity<i16, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for i32 {
    type Output = Quantity<i32, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for i64 {
    type Output = Quantity<i64, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for i128 {
    type Output = Quantity<i128, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for isize {
    type Output = Quantity<isize, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for u8 {
    type Output = Quantity<u8, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for u16 {
    type Output = Quantity<u16, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for u32 {
    type Output = Quantity<u32, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for u64 {
    type Output = Quantity<u64, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for u128 {
    type Output = Quantity<u128, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for usize {
    type Output = Quantity<usize, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for f32 {
    type Output = Quantity<f32, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
impl Mul<UnitDecaphotsMul> for f64 {
    type Output = Quantity<f64, UnitDecaphots>;
    fn mul(self, _: UnitDecaphotsMul) -> Self::Output {
        Quantity::new(self, UnitDecaphots)
    }
}
pub struct UnitDeciphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciphots {
    #[inline]
    fn clone(&self) -> UnitDeciphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciphots {
    #[inline]
    fn eq(&self, other: &UnitDeciphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciphots {
    fn default() -> Self {
        UnitDeciphots
    }
}
impl Add<UnitDeciphots> for UnitDeciphots {
    type Output = UnitDeciphots;
    #[inline]
    fn add(self, _: UnitDeciphots) -> Self::Output {
        UnitDeciphots
    }
}
impl AddAssign<UnitDeciphots> for UnitDeciphots {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciphots) {}
}
impl Sub<UnitDeciphots> for UnitDeciphots {
    type Output = UnitDeciphots;
    #[inline]
    fn sub(self, _: UnitDeciphots) -> Self::Output {
        UnitDeciphots
    }
}
impl SubAssign<UnitDeciphots> for UnitDeciphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciphots) {}
}
pub struct UnitDeciphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciphotsMul {
    #[inline]
    fn clone(&self) -> UnitDeciphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciphotsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciphotsMul> for i8 {
    type Output = Quantity<i8, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for i16 {
    type Output = Quantity<i16, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for i32 {
    type Output = Quantity<i32, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for i64 {
    type Output = Quantity<i64, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for i128 {
    type Output = Quantity<i128, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for isize {
    type Output = Quantity<isize, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for u8 {
    type Output = Quantity<u8, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for u16 {
    type Output = Quantity<u16, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for u32 {
    type Output = Quantity<u32, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for u64 {
    type Output = Quantity<u64, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for u128 {
    type Output = Quantity<u128, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for usize {
    type Output = Quantity<usize, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for f32 {
    type Output = Quantity<f32, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
impl Mul<UnitDeciphotsMul> for f64 {
    type Output = Quantity<f64, UnitDeciphots>;
    fn mul(self, _: UnitDeciphotsMul) -> Self::Output {
        Quantity::new(self, UnitDeciphots)
    }
}
pub struct UnitCentiphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiphots {
    #[inline]
    fn clone(&self) -> UnitCentiphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiphots {
    #[inline]
    fn eq(&self, other: &UnitCentiphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiphots {
    fn default() -> Self {
        UnitCentiphots
    }
}
impl Add<UnitCentiphots> for UnitCentiphots {
    type Output = UnitCentiphots;
    #[inline]
    fn add(self, _: UnitCentiphots) -> Self::Output {
        UnitCentiphots
    }
}
impl AddAssign<UnitCentiphots> for UnitCentiphots {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiphots) {}
}
impl Sub<UnitCentiphots> for UnitCentiphots {
    type Output = UnitCentiphots;
    #[inline]
    fn sub(self, _: UnitCentiphots) -> Self::Output {
        UnitCentiphots
    }
}
impl SubAssign<UnitCentiphots> for UnitCentiphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiphots) {}
}
pub struct UnitCentiphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiphotsMul {
    #[inline]
    fn clone(&self) -> UnitCentiphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiphotsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiphotsMul> for i8 {
    type Output = Quantity<i8, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for i16 {
    type Output = Quantity<i16, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for i32 {
    type Output = Quantity<i32, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for i64 {
    type Output = Quantity<i64, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for i128 {
    type Output = Quantity<i128, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for isize {
    type Output = Quantity<isize, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for u8 {
    type Output = Quantity<u8, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for u16 {
    type Output = Quantity<u16, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for u32 {
    type Output = Quantity<u32, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for u64 {
    type Output = Quantity<u64, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for u128 {
    type Output = Quantity<u128, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for usize {
    type Output = Quantity<usize, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for f32 {
    type Output = Quantity<f32, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
impl Mul<UnitCentiphotsMul> for f64 {
    type Output = Quantity<f64, UnitCentiphots>;
    fn mul(self, _: UnitCentiphotsMul) -> Self::Output {
        Quantity::new(self, UnitCentiphots)
    }
}
pub struct UnitMilliphots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliphots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliphots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliphots {
    #[inline]
    fn clone(&self) -> UnitMilliphots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliphots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliphots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliphots {
    #[inline]
    fn eq(&self, other: &UnitMilliphots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliphots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliphots {
    fn default() -> Self {
        UnitMilliphots
    }
}
impl Add<UnitMilliphots> for UnitMilliphots {
    type Output = UnitMilliphots;
    #[inline]
    fn add(self, _: UnitMilliphots) -> Self::Output {
        UnitMilliphots
    }
}
impl AddAssign<UnitMilliphots> for UnitMilliphots {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliphots) {}
}
impl Sub<UnitMilliphots> for UnitMilliphots {
    type Output = UnitMilliphots;
    #[inline]
    fn sub(self, _: UnitMilliphots) -> Self::Output {
        UnitMilliphots
    }
}
impl SubAssign<UnitMilliphots> for UnitMilliphots {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliphots) {}
}
pub struct UnitMilliphotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliphotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliphotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliphotsMul {
    #[inline]
    fn clone(&self) -> UnitMilliphotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliphotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliphotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliphotsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliphotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliphotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliphotsMul> for i8 {
    type Output = Quantity<i8, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for i16 {
    type Output = Quantity<i16, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for i32 {
    type Output = Quantity<i32, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for i64 {
    type Output = Quantity<i64, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for i128 {
    type Output = Quantity<i128, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for isize {
    type Output = Quantity<isize, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for u8 {
    type Output = Quantity<u8, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for u16 {
    type Output = Quantity<u16, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for u32 {
    type Output = Quantity<u32, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for u64 {
    type Output = Quantity<u64, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for u128 {
    type Output = Quantity<u128, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for usize {
    type Output = Quantity<usize, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for f32 {
    type Output = Quantity<f32, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
impl Mul<UnitMilliphotsMul> for f64 {
    type Output = Quantity<f64, UnitMilliphots>;
    fn mul(self, _: UnitMilliphotsMul) -> Self::Output {
        Quantity::new(self, UnitMilliphots)
    }
}
pub struct UnitMicrophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrophots {
    #[inline]
    fn clone(&self) -> UnitMicrophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrophots {
    #[inline]
    fn eq(&self, other: &UnitMicrophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrophots {
    fn default() -> Self {
        UnitMicrophots
    }
}
impl Add<UnitMicrophots> for UnitMicrophots {
    type Output = UnitMicrophots;
    #[inline]
    fn add(self, _: UnitMicrophots) -> Self::Output {
        UnitMicrophots
    }
}
impl AddAssign<UnitMicrophots> for UnitMicrophots {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrophots) {}
}
impl Sub<UnitMicrophots> for UnitMicrophots {
    type Output = UnitMicrophots;
    #[inline]
    fn sub(self, _: UnitMicrophots) -> Self::Output {
        UnitMicrophots
    }
}
impl SubAssign<UnitMicrophots> for UnitMicrophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrophots) {}
}
pub struct UnitMicrophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrophotsMul {
    #[inline]
    fn clone(&self) -> UnitMicrophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrophotsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrophotsMul> for i8 {
    type Output = Quantity<i8, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for i16 {
    type Output = Quantity<i16, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for i32 {
    type Output = Quantity<i32, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for i64 {
    type Output = Quantity<i64, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for i128 {
    type Output = Quantity<i128, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for isize {
    type Output = Quantity<isize, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for u8 {
    type Output = Quantity<u8, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for u16 {
    type Output = Quantity<u16, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for u32 {
    type Output = Quantity<u32, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for u64 {
    type Output = Quantity<u64, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for u128 {
    type Output = Quantity<u128, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for usize {
    type Output = Quantity<usize, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for f32 {
    type Output = Quantity<f32, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
impl Mul<UnitMicrophotsMul> for f64 {
    type Output = Quantity<f64, UnitMicrophots>;
    fn mul(self, _: UnitMicrophotsMul) -> Self::Output {
        Quantity::new(self, UnitMicrophots)
    }
}
pub struct UnitNanophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanophots {
    #[inline]
    fn clone(&self) -> UnitNanophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanophots {
    #[inline]
    fn eq(&self, other: &UnitNanophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanophots {
    fn default() -> Self {
        UnitNanophots
    }
}
impl Add<UnitNanophots> for UnitNanophots {
    type Output = UnitNanophots;
    #[inline]
    fn add(self, _: UnitNanophots) -> Self::Output {
        UnitNanophots
    }
}
impl AddAssign<UnitNanophots> for UnitNanophots {
    #[inline]
    fn add_assign(&mut self, _: UnitNanophots) {}
}
impl Sub<UnitNanophots> for UnitNanophots {
    type Output = UnitNanophots;
    #[inline]
    fn sub(self, _: UnitNanophots) -> Self::Output {
        UnitNanophots
    }
}
impl SubAssign<UnitNanophots> for UnitNanophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanophots) {}
}
pub struct UnitNanophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanophotsMul {
    #[inline]
    fn clone(&self) -> UnitNanophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanophotsMul {
    #[inline]
    fn eq(&self, other: &UnitNanophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanophotsMul> for i8 {
    type Output = Quantity<i8, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for i16 {
    type Output = Quantity<i16, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for i32 {
    type Output = Quantity<i32, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for i64 {
    type Output = Quantity<i64, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for i128 {
    type Output = Quantity<i128, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for isize {
    type Output = Quantity<isize, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for u8 {
    type Output = Quantity<u8, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for u16 {
    type Output = Quantity<u16, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for u32 {
    type Output = Quantity<u32, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for u64 {
    type Output = Quantity<u64, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for u128 {
    type Output = Quantity<u128, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for usize {
    type Output = Quantity<usize, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for f32 {
    type Output = Quantity<f32, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
impl Mul<UnitNanophotsMul> for f64 {
    type Output = Quantity<f64, UnitNanophots>;
    fn mul(self, _: UnitNanophotsMul) -> Self::Output {
        Quantity::new(self, UnitNanophots)
    }
}
pub struct UnitPicophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicophots {
    #[inline]
    fn clone(&self) -> UnitPicophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicophots {
    #[inline]
    fn eq(&self, other: &UnitPicophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicophots {
    fn default() -> Self {
        UnitPicophots
    }
}
impl Add<UnitPicophots> for UnitPicophots {
    type Output = UnitPicophots;
    #[inline]
    fn add(self, _: UnitPicophots) -> Self::Output {
        UnitPicophots
    }
}
impl AddAssign<UnitPicophots> for UnitPicophots {
    #[inline]
    fn add_assign(&mut self, _: UnitPicophots) {}
}
impl Sub<UnitPicophots> for UnitPicophots {
    type Output = UnitPicophots;
    #[inline]
    fn sub(self, _: UnitPicophots) -> Self::Output {
        UnitPicophots
    }
}
impl SubAssign<UnitPicophots> for UnitPicophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicophots) {}
}
pub struct UnitPicophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicophotsMul {
    #[inline]
    fn clone(&self) -> UnitPicophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicophotsMul {
    #[inline]
    fn eq(&self, other: &UnitPicophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicophotsMul> for i8 {
    type Output = Quantity<i8, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for i16 {
    type Output = Quantity<i16, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for i32 {
    type Output = Quantity<i32, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for i64 {
    type Output = Quantity<i64, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for i128 {
    type Output = Quantity<i128, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for isize {
    type Output = Quantity<isize, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for u8 {
    type Output = Quantity<u8, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for u16 {
    type Output = Quantity<u16, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for u32 {
    type Output = Quantity<u32, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for u64 {
    type Output = Quantity<u64, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for u128 {
    type Output = Quantity<u128, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for usize {
    type Output = Quantity<usize, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for f32 {
    type Output = Quantity<f32, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
impl Mul<UnitPicophotsMul> for f64 {
    type Output = Quantity<f64, UnitPicophots>;
    fn mul(self, _: UnitPicophotsMul) -> Self::Output {
        Quantity::new(self, UnitPicophots)
    }
}
pub struct UnitFemtophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtophots {
    #[inline]
    fn clone(&self) -> UnitFemtophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtophots {
    #[inline]
    fn eq(&self, other: &UnitFemtophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtophots {
    fn default() -> Self {
        UnitFemtophots
    }
}
impl Add<UnitFemtophots> for UnitFemtophots {
    type Output = UnitFemtophots;
    #[inline]
    fn add(self, _: UnitFemtophots) -> Self::Output {
        UnitFemtophots
    }
}
impl AddAssign<UnitFemtophots> for UnitFemtophots {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtophots) {}
}
impl Sub<UnitFemtophots> for UnitFemtophots {
    type Output = UnitFemtophots;
    #[inline]
    fn sub(self, _: UnitFemtophots) -> Self::Output {
        UnitFemtophots
    }
}
impl SubAssign<UnitFemtophots> for UnitFemtophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtophots) {}
}
pub struct UnitFemtophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtophotsMul {
    #[inline]
    fn clone(&self) -> UnitFemtophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtophotsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtophotsMul> for i8 {
    type Output = Quantity<i8, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for i16 {
    type Output = Quantity<i16, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for i32 {
    type Output = Quantity<i32, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for i64 {
    type Output = Quantity<i64, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for i128 {
    type Output = Quantity<i128, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for isize {
    type Output = Quantity<isize, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for u8 {
    type Output = Quantity<u8, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for u16 {
    type Output = Quantity<u16, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for u32 {
    type Output = Quantity<u32, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for u64 {
    type Output = Quantity<u64, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for u128 {
    type Output = Quantity<u128, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for usize {
    type Output = Quantity<usize, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for f32 {
    type Output = Quantity<f32, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
impl Mul<UnitFemtophotsMul> for f64 {
    type Output = Quantity<f64, UnitFemtophots>;
    fn mul(self, _: UnitFemtophotsMul) -> Self::Output {
        Quantity::new(self, UnitFemtophots)
    }
}
pub struct UnitAttophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttophots {
    #[inline]
    fn clone(&self) -> UnitAttophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttophots {
    #[inline]
    fn eq(&self, other: &UnitAttophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttophots {
    fn default() -> Self {
        UnitAttophots
    }
}
impl Add<UnitAttophots> for UnitAttophots {
    type Output = UnitAttophots;
    #[inline]
    fn add(self, _: UnitAttophots) -> Self::Output {
        UnitAttophots
    }
}
impl AddAssign<UnitAttophots> for UnitAttophots {
    #[inline]
    fn add_assign(&mut self, _: UnitAttophots) {}
}
impl Sub<UnitAttophots> for UnitAttophots {
    type Output = UnitAttophots;
    #[inline]
    fn sub(self, _: UnitAttophots) -> Self::Output {
        UnitAttophots
    }
}
impl SubAssign<UnitAttophots> for UnitAttophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttophots) {}
}
pub struct UnitAttophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttophotsMul {
    #[inline]
    fn clone(&self) -> UnitAttophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttophotsMul {
    #[inline]
    fn eq(&self, other: &UnitAttophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttophotsMul> for i8 {
    type Output = Quantity<i8, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for i16 {
    type Output = Quantity<i16, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for i32 {
    type Output = Quantity<i32, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for i64 {
    type Output = Quantity<i64, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for i128 {
    type Output = Quantity<i128, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for isize {
    type Output = Quantity<isize, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for u8 {
    type Output = Quantity<u8, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for u16 {
    type Output = Quantity<u16, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for u32 {
    type Output = Quantity<u32, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for u64 {
    type Output = Quantity<u64, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for u128 {
    type Output = Quantity<u128, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for usize {
    type Output = Quantity<usize, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for f32 {
    type Output = Quantity<f32, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
impl Mul<UnitAttophotsMul> for f64 {
    type Output = Quantity<f64, UnitAttophots>;
    fn mul(self, _: UnitAttophotsMul) -> Self::Output {
        Quantity::new(self, UnitAttophots)
    }
}
pub struct UnitZeptophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptophots {
    #[inline]
    fn clone(&self) -> UnitZeptophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptophots {
    #[inline]
    fn eq(&self, other: &UnitZeptophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptophots {
    fn default() -> Self {
        UnitZeptophots
    }
}
impl Add<UnitZeptophots> for UnitZeptophots {
    type Output = UnitZeptophots;
    #[inline]
    fn add(self, _: UnitZeptophots) -> Self::Output {
        UnitZeptophots
    }
}
impl AddAssign<UnitZeptophots> for UnitZeptophots {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptophots) {}
}
impl Sub<UnitZeptophots> for UnitZeptophots {
    type Output = UnitZeptophots;
    #[inline]
    fn sub(self, _: UnitZeptophots) -> Self::Output {
        UnitZeptophots
    }
}
impl SubAssign<UnitZeptophots> for UnitZeptophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptophots) {}
}
pub struct UnitZeptophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptophotsMul {
    #[inline]
    fn clone(&self) -> UnitZeptophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptophotsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptophotsMul> for i8 {
    type Output = Quantity<i8, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for i16 {
    type Output = Quantity<i16, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for i32 {
    type Output = Quantity<i32, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for i64 {
    type Output = Quantity<i64, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for i128 {
    type Output = Quantity<i128, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for isize {
    type Output = Quantity<isize, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for u8 {
    type Output = Quantity<u8, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for u16 {
    type Output = Quantity<u16, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for u32 {
    type Output = Quantity<u32, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for u64 {
    type Output = Quantity<u64, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for u128 {
    type Output = Quantity<u128, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for usize {
    type Output = Quantity<usize, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for f32 {
    type Output = Quantity<f32, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
impl Mul<UnitZeptophotsMul> for f64 {
    type Output = Quantity<f64, UnitZeptophots>;
    fn mul(self, _: UnitZeptophotsMul) -> Self::Output {
        Quantity::new(self, UnitZeptophots)
    }
}
pub struct UnitYoctophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctophots {
    #[inline]
    fn clone(&self) -> UnitYoctophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctophots {
    #[inline]
    fn eq(&self, other: &UnitYoctophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctophots {
    fn default() -> Self {
        UnitYoctophots
    }
}
impl Add<UnitYoctophots> for UnitYoctophots {
    type Output = UnitYoctophots;
    #[inline]
    fn add(self, _: UnitYoctophots) -> Self::Output {
        UnitYoctophots
    }
}
impl AddAssign<UnitYoctophots> for UnitYoctophots {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctophots) {}
}
impl Sub<UnitYoctophots> for UnitYoctophots {
    type Output = UnitYoctophots;
    #[inline]
    fn sub(self, _: UnitYoctophots) -> Self::Output {
        UnitYoctophots
    }
}
impl SubAssign<UnitYoctophots> for UnitYoctophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctophots) {}
}
pub struct UnitYoctophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctophotsMul {
    #[inline]
    fn clone(&self) -> UnitYoctophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctophotsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctophotsMul> for i8 {
    type Output = Quantity<i8, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for i16 {
    type Output = Quantity<i16, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for i32 {
    type Output = Quantity<i32, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for i64 {
    type Output = Quantity<i64, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for i128 {
    type Output = Quantity<i128, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for isize {
    type Output = Quantity<isize, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for u8 {
    type Output = Quantity<u8, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for u16 {
    type Output = Quantity<u16, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for u32 {
    type Output = Quantity<u32, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for u64 {
    type Output = Quantity<u64, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for u128 {
    type Output = Quantity<u128, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for usize {
    type Output = Quantity<usize, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for f32 {
    type Output = Quantity<f32, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
impl Mul<UnitYoctophotsMul> for f64 {
    type Output = Quantity<f64, UnitYoctophots>;
    fn mul(self, _: UnitYoctophotsMul) -> Self::Output {
        Quantity::new(self, UnitYoctophots)
    }
}
pub struct UnitRontophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontophots {
    #[inline]
    fn clone(&self) -> UnitRontophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontophots {
    #[inline]
    fn eq(&self, other: &UnitRontophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontophots {
    fn default() -> Self {
        UnitRontophots
    }
}
impl Add<UnitRontophots> for UnitRontophots {
    type Output = UnitRontophots;
    #[inline]
    fn add(self, _: UnitRontophots) -> Self::Output {
        UnitRontophots
    }
}
impl AddAssign<UnitRontophots> for UnitRontophots {
    #[inline]
    fn add_assign(&mut self, _: UnitRontophots) {}
}
impl Sub<UnitRontophots> for UnitRontophots {
    type Output = UnitRontophots;
    #[inline]
    fn sub(self, _: UnitRontophots) -> Self::Output {
        UnitRontophots
    }
}
impl SubAssign<UnitRontophots> for UnitRontophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontophots) {}
}
pub struct UnitRontophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontophotsMul {
    #[inline]
    fn clone(&self) -> UnitRontophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontophotsMul {
    #[inline]
    fn eq(&self, other: &UnitRontophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontophotsMul> for i8 {
    type Output = Quantity<i8, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for i16 {
    type Output = Quantity<i16, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for i32 {
    type Output = Quantity<i32, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for i64 {
    type Output = Quantity<i64, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for i128 {
    type Output = Quantity<i128, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for isize {
    type Output = Quantity<isize, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for u8 {
    type Output = Quantity<u8, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for u16 {
    type Output = Quantity<u16, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for u32 {
    type Output = Quantity<u32, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for u64 {
    type Output = Quantity<u64, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for u128 {
    type Output = Quantity<u128, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for usize {
    type Output = Quantity<usize, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for f32 {
    type Output = Quantity<f32, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
impl Mul<UnitRontophotsMul> for f64 {
    type Output = Quantity<f64, UnitRontophots>;
    fn mul(self, _: UnitRontophotsMul) -> Self::Output {
        Quantity::new(self, UnitRontophots)
    }
}
pub struct UnitQuectophots;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectophots {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectophots")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectophots {
    #[inline]
    fn clone(&self) -> UnitQuectophots {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectophots {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectophots {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectophots {
    #[inline]
    fn eq(&self, other: &UnitQuectophots) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectophots {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectophots {
    fn default() -> Self {
        UnitQuectophots
    }
}
impl Add<UnitQuectophots> for UnitQuectophots {
    type Output = UnitQuectophots;
    #[inline]
    fn add(self, _: UnitQuectophots) -> Self::Output {
        UnitQuectophots
    }
}
impl AddAssign<UnitQuectophots> for UnitQuectophots {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectophots) {}
}
impl Sub<UnitQuectophots> for UnitQuectophots {
    type Output = UnitQuectophots;
    #[inline]
    fn sub(self, _: UnitQuectophots) -> Self::Output {
        UnitQuectophots
    }
}
impl SubAssign<UnitQuectophots> for UnitQuectophots {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectophots) {}
}
pub struct UnitQuectophotsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectophotsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectophotsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectophotsMul {
    #[inline]
    fn clone(&self) -> UnitQuectophotsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectophotsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectophotsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectophotsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectophotsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectophotsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectophotsMul> for i8 {
    type Output = Quantity<i8, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for i16 {
    type Output = Quantity<i16, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for i32 {
    type Output = Quantity<i32, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for i64 {
    type Output = Quantity<i64, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for i128 {
    type Output = Quantity<i128, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for isize {
    type Output = Quantity<isize, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for u8 {
    type Output = Quantity<u8, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for u16 {
    type Output = Quantity<u16, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for u32 {
    type Output = Quantity<u32, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for u64 {
    type Output = Quantity<u64, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for u128 {
    type Output = Quantity<u128, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for usize {
    type Output = Quantity<usize, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for f32 {
    type Output = Quantity<f32, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
impl Mul<UnitQuectophotsMul> for f64 {
    type Output = Quantity<f64, UnitQuectophots>;
    fn mul(self, _: UnitQuectophotsMul) -> Self::Output {
        Quantity::new(self, UnitQuectophots)
    }
}
pub type Phots<T> = Quantity<T, UnitPhots>;
#[allow(non_upper_case_globals)]
pub static Phots: UnitPhotsMul = UnitPhotsMul;
pub type Quettaphots<T> = Quantity<T, UnitQuettaphots>;
#[allow(non_upper_case_globals)]
pub static Quettaphots: UnitQuettaphotsMul = UnitQuettaphotsMul;
pub type Ronnaphots<T> = Quantity<T, UnitRonnaphots>;
#[allow(non_upper_case_globals)]
pub static Ronnaphots: UnitRonnaphotsMul = UnitRonnaphotsMul;
pub type Yottaphots<T> = Quantity<T, UnitYottaphots>;
#[allow(non_upper_case_globals)]
pub static Yottaphots: UnitYottaphotsMul = UnitYottaphotsMul;
pub type Zettaphots<T> = Quantity<T, UnitZettaphots>;
#[allow(non_upper_case_globals)]
pub static Zettaphots: UnitZettaphotsMul = UnitZettaphotsMul;
pub type Exaphots<T> = Quantity<T, UnitExaphots>;
#[allow(non_upper_case_globals)]
pub static Exaphots: UnitExaphotsMul = UnitExaphotsMul;
pub type Petaphots<T> = Quantity<T, UnitPetaphots>;
#[allow(non_upper_case_globals)]
pub static Petaphots: UnitPetaphotsMul = UnitPetaphotsMul;
pub type Teraphots<T> = Quantity<T, UnitTeraphots>;
#[allow(non_upper_case_globals)]
pub static Teraphots: UnitTeraphotsMul = UnitTeraphotsMul;
pub type Gigaphots<T> = Quantity<T, UnitGigaphots>;
#[allow(non_upper_case_globals)]
pub static Gigaphots: UnitGigaphotsMul = UnitGigaphotsMul;
pub type Megaphots<T> = Quantity<T, UnitMegaphots>;
#[allow(non_upper_case_globals)]
pub static Megaphots: UnitMegaphotsMul = UnitMegaphotsMul;
pub type Kilophots<T> = Quantity<T, UnitKilophots>;
#[allow(non_upper_case_globals)]
pub static Kilophots: UnitKilophotsMul = UnitKilophotsMul;
pub type Hectophots<T> = Quantity<T, UnitHectophots>;
#[allow(non_upper_case_globals)]
pub static Hectophots: UnitHectophotsMul = UnitHectophotsMul;
pub type Decaphots<T> = Quantity<T, UnitDecaphots>;
#[allow(non_upper_case_globals)]
pub static Decaphots: UnitDecaphotsMul = UnitDecaphotsMul;
pub type Deciphots<T> = Quantity<T, UnitDeciphots>;
#[allow(non_upper_case_globals)]
pub static Deciphots: UnitDeciphotsMul = UnitDeciphotsMul;
pub type Centiphots<T> = Quantity<T, UnitCentiphots>;
#[allow(non_upper_case_globals)]
pub static Centiphots: UnitCentiphotsMul = UnitCentiphotsMul;
pub type Milliphots<T> = Quantity<T, UnitMilliphots>;
#[allow(non_upper_case_globals)]
pub static Milliphots: UnitMilliphotsMul = UnitMilliphotsMul;
pub type Microphots<T> = Quantity<T, UnitMicrophots>;
#[allow(non_upper_case_globals)]
pub static Microphots: UnitMicrophotsMul = UnitMicrophotsMul;
pub type Nanophots<T> = Quantity<T, UnitNanophots>;
#[allow(non_upper_case_globals)]
pub static Nanophots: UnitNanophotsMul = UnitNanophotsMul;
pub type Picophots<T> = Quantity<T, UnitPicophots>;
#[allow(non_upper_case_globals)]
pub static Picophots: UnitPicophotsMul = UnitPicophotsMul;
pub type Femtophots<T> = Quantity<T, UnitFemtophots>;
#[allow(non_upper_case_globals)]
pub static Femtophots: UnitFemtophotsMul = UnitFemtophotsMul;
pub type Attophots<T> = Quantity<T, UnitAttophots>;
#[allow(non_upper_case_globals)]
pub static Attophots: UnitAttophotsMul = UnitAttophotsMul;
pub type Zeptophots<T> = Quantity<T, UnitZeptophots>;
#[allow(non_upper_case_globals)]
pub static Zeptophots: UnitZeptophotsMul = UnitZeptophotsMul;
pub type Yoctophots<T> = Quantity<T, UnitYoctophots>;
#[allow(non_upper_case_globals)]
pub static Yoctophots: UnitYoctophotsMul = UnitYoctophotsMul;
pub type Rontophots<T> = Quantity<T, UnitRontophots>;
#[allow(non_upper_case_globals)]
pub static Rontophots: UnitRontophotsMul = UnitRontophotsMul;
pub type Quectophots<T> = Quantity<T, UnitQuectophots>;
#[allow(non_upper_case_globals)]
pub static Quectophots: UnitQuectophotsMul = UnitQuectophotsMul;
pub struct UnitRayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRayls {
    #[inline]
    fn clone(&self) -> UnitRayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRayls {
    #[inline]
    fn eq(&self, other: &UnitRayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRayls {
    fn default() -> Self {
        UnitRayls
    }
}
impl Add<UnitRayls> for UnitRayls {
    type Output = UnitRayls;
    #[inline]
    fn add(self, _: UnitRayls) -> Self::Output {
        UnitRayls
    }
}
impl AddAssign<UnitRayls> for UnitRayls {
    #[inline]
    fn add_assign(&mut self, _: UnitRayls) {}
}
impl Sub<UnitRayls> for UnitRayls {
    type Output = UnitRayls;
    #[inline]
    fn sub(self, _: UnitRayls) -> Self::Output {
        UnitRayls
    }
}
impl SubAssign<UnitRayls> for UnitRayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitRayls) {}
}
pub struct UnitRaylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRaylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRaylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRaylsMul {
    #[inline]
    fn clone(&self) -> UnitRaylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRaylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRaylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRaylsMul {
    #[inline]
    fn eq(&self, other: &UnitRaylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRaylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRaylsMul> for i8 {
    type Output = Quantity<i8, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for i16 {
    type Output = Quantity<i16, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for i32 {
    type Output = Quantity<i32, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for i64 {
    type Output = Quantity<i64, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for i128 {
    type Output = Quantity<i128, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for isize {
    type Output = Quantity<isize, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for u8 {
    type Output = Quantity<u8, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for u16 {
    type Output = Quantity<u16, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for u32 {
    type Output = Quantity<u32, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for u64 {
    type Output = Quantity<u64, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for u128 {
    type Output = Quantity<u128, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for usize {
    type Output = Quantity<usize, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for f32 {
    type Output = Quantity<f32, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
impl Mul<UnitRaylsMul> for f64 {
    type Output = Quantity<f64, UnitRayls>;
    fn mul(self, _: UnitRaylsMul) -> Self::Output {
        Quantity::new(self, UnitRayls)
    }
}
pub struct UnitQuettarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettarayls {
    #[inline]
    fn clone(&self) -> UnitQuettarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettarayls {
    #[inline]
    fn eq(&self, other: &UnitQuettarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettarayls {
    fn default() -> Self {
        UnitQuettarayls
    }
}
impl Add<UnitQuettarayls> for UnitQuettarayls {
    type Output = UnitQuettarayls;
    #[inline]
    fn add(self, _: UnitQuettarayls) -> Self::Output {
        UnitQuettarayls
    }
}
impl AddAssign<UnitQuettarayls> for UnitQuettarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettarayls) {}
}
impl Sub<UnitQuettarayls> for UnitQuettarayls {
    type Output = UnitQuettarayls;
    #[inline]
    fn sub(self, _: UnitQuettarayls) -> Self::Output {
        UnitQuettarayls
    }
}
impl SubAssign<UnitQuettarayls> for UnitQuettarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettarayls) {}
}
pub struct UnitQuettaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaraylsMul {
    #[inline]
    fn clone(&self) -> UnitQuettaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaraylsMul> for i8 {
    type Output = Quantity<i8, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for i16 {
    type Output = Quantity<i16, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for i32 {
    type Output = Quantity<i32, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for i64 {
    type Output = Quantity<i64, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for i128 {
    type Output = Quantity<i128, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for isize {
    type Output = Quantity<isize, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for u8 {
    type Output = Quantity<u8, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for u16 {
    type Output = Quantity<u16, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for u32 {
    type Output = Quantity<u32, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for u64 {
    type Output = Quantity<u64, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for u128 {
    type Output = Quantity<u128, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for usize {
    type Output = Quantity<usize, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for f32 {
    type Output = Quantity<f32, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
impl Mul<UnitQuettaraylsMul> for f64 {
    type Output = Quantity<f64, UnitQuettarayls>;
    fn mul(self, _: UnitQuettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettarayls)
    }
}
pub struct UnitRonnarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnarayls {
    #[inline]
    fn clone(&self) -> UnitRonnarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnarayls {
    #[inline]
    fn eq(&self, other: &UnitRonnarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnarayls {
    fn default() -> Self {
        UnitRonnarayls
    }
}
impl Add<UnitRonnarayls> for UnitRonnarayls {
    type Output = UnitRonnarayls;
    #[inline]
    fn add(self, _: UnitRonnarayls) -> Self::Output {
        UnitRonnarayls
    }
}
impl AddAssign<UnitRonnarayls> for UnitRonnarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnarayls) {}
}
impl Sub<UnitRonnarayls> for UnitRonnarayls {
    type Output = UnitRonnarayls;
    #[inline]
    fn sub(self, _: UnitRonnarayls) -> Self::Output {
        UnitRonnarayls
    }
}
impl SubAssign<UnitRonnarayls> for UnitRonnarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnarayls) {}
}
pub struct UnitRonnaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaraylsMul {
    #[inline]
    fn clone(&self) -> UnitRonnaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaraylsMul> for i8 {
    type Output = Quantity<i8, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for i16 {
    type Output = Quantity<i16, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for i32 {
    type Output = Quantity<i32, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for i64 {
    type Output = Quantity<i64, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for i128 {
    type Output = Quantity<i128, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for isize {
    type Output = Quantity<isize, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for u8 {
    type Output = Quantity<u8, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for u16 {
    type Output = Quantity<u16, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for u32 {
    type Output = Quantity<u32, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for u64 {
    type Output = Quantity<u64, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for u128 {
    type Output = Quantity<u128, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for usize {
    type Output = Quantity<usize, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for f32 {
    type Output = Quantity<f32, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
impl Mul<UnitRonnaraylsMul> for f64 {
    type Output = Quantity<f64, UnitRonnarayls>;
    fn mul(self, _: UnitRonnaraylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnarayls)
    }
}
pub struct UnitYottarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottarayls {
    #[inline]
    fn clone(&self) -> UnitYottarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottarayls {
    #[inline]
    fn eq(&self, other: &UnitYottarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottarayls {
    fn default() -> Self {
        UnitYottarayls
    }
}
impl Add<UnitYottarayls> for UnitYottarayls {
    type Output = UnitYottarayls;
    #[inline]
    fn add(self, _: UnitYottarayls) -> Self::Output {
        UnitYottarayls
    }
}
impl AddAssign<UnitYottarayls> for UnitYottarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitYottarayls) {}
}
impl Sub<UnitYottarayls> for UnitYottarayls {
    type Output = UnitYottarayls;
    #[inline]
    fn sub(self, _: UnitYottarayls) -> Self::Output {
        UnitYottarayls
    }
}
impl SubAssign<UnitYottarayls> for UnitYottarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottarayls) {}
}
pub struct UnitYottaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaraylsMul {
    #[inline]
    fn clone(&self) -> UnitYottaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitYottaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaraylsMul> for i8 {
    type Output = Quantity<i8, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for i16 {
    type Output = Quantity<i16, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for i32 {
    type Output = Quantity<i32, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for i64 {
    type Output = Quantity<i64, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for i128 {
    type Output = Quantity<i128, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for isize {
    type Output = Quantity<isize, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for u8 {
    type Output = Quantity<u8, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for u16 {
    type Output = Quantity<u16, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for u32 {
    type Output = Quantity<u32, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for u64 {
    type Output = Quantity<u64, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for u128 {
    type Output = Quantity<u128, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for usize {
    type Output = Quantity<usize, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for f32 {
    type Output = Quantity<f32, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
impl Mul<UnitYottaraylsMul> for f64 {
    type Output = Quantity<f64, UnitYottarayls>;
    fn mul(self, _: UnitYottaraylsMul) -> Self::Output {
        Quantity::new(self, UnitYottarayls)
    }
}
pub struct UnitZettarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettarayls {
    #[inline]
    fn clone(&self) -> UnitZettarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettarayls {
    #[inline]
    fn eq(&self, other: &UnitZettarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettarayls {
    fn default() -> Self {
        UnitZettarayls
    }
}
impl Add<UnitZettarayls> for UnitZettarayls {
    type Output = UnitZettarayls;
    #[inline]
    fn add(self, _: UnitZettarayls) -> Self::Output {
        UnitZettarayls
    }
}
impl AddAssign<UnitZettarayls> for UnitZettarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitZettarayls) {}
}
impl Sub<UnitZettarayls> for UnitZettarayls {
    type Output = UnitZettarayls;
    #[inline]
    fn sub(self, _: UnitZettarayls) -> Self::Output {
        UnitZettarayls
    }
}
impl SubAssign<UnitZettarayls> for UnitZettarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettarayls) {}
}
pub struct UnitZettaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaraylsMul {
    #[inline]
    fn clone(&self) -> UnitZettaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitZettaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaraylsMul> for i8 {
    type Output = Quantity<i8, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for i16 {
    type Output = Quantity<i16, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for i32 {
    type Output = Quantity<i32, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for i64 {
    type Output = Quantity<i64, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for i128 {
    type Output = Quantity<i128, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for isize {
    type Output = Quantity<isize, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for u8 {
    type Output = Quantity<u8, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for u16 {
    type Output = Quantity<u16, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for u32 {
    type Output = Quantity<u32, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for u64 {
    type Output = Quantity<u64, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for u128 {
    type Output = Quantity<u128, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for usize {
    type Output = Quantity<usize, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for f32 {
    type Output = Quantity<f32, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
impl Mul<UnitZettaraylsMul> for f64 {
    type Output = Quantity<f64, UnitZettarayls>;
    fn mul(self, _: UnitZettaraylsMul) -> Self::Output {
        Quantity::new(self, UnitZettarayls)
    }
}
pub struct UnitExarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExarayls {
    #[inline]
    fn clone(&self) -> UnitExarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExarayls {
    #[inline]
    fn eq(&self, other: &UnitExarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExarayls {
    fn default() -> Self {
        UnitExarayls
    }
}
impl Add<UnitExarayls> for UnitExarayls {
    type Output = UnitExarayls;
    #[inline]
    fn add(self, _: UnitExarayls) -> Self::Output {
        UnitExarayls
    }
}
impl AddAssign<UnitExarayls> for UnitExarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitExarayls) {}
}
impl Sub<UnitExarayls> for UnitExarayls {
    type Output = UnitExarayls;
    #[inline]
    fn sub(self, _: UnitExarayls) -> Self::Output {
        UnitExarayls
    }
}
impl SubAssign<UnitExarayls> for UnitExarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitExarayls) {}
}
pub struct UnitExaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaraylsMul {
    #[inline]
    fn clone(&self) -> UnitExaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitExaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaraylsMul> for i8 {
    type Output = Quantity<i8, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for i16 {
    type Output = Quantity<i16, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for i32 {
    type Output = Quantity<i32, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for i64 {
    type Output = Quantity<i64, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for i128 {
    type Output = Quantity<i128, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for isize {
    type Output = Quantity<isize, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for u8 {
    type Output = Quantity<u8, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for u16 {
    type Output = Quantity<u16, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for u32 {
    type Output = Quantity<u32, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for u64 {
    type Output = Quantity<u64, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for u128 {
    type Output = Quantity<u128, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for usize {
    type Output = Quantity<usize, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for f32 {
    type Output = Quantity<f32, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
impl Mul<UnitExaraylsMul> for f64 {
    type Output = Quantity<f64, UnitExarayls>;
    fn mul(self, _: UnitExaraylsMul) -> Self::Output {
        Quantity::new(self, UnitExarayls)
    }
}
pub struct UnitPetarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetarayls {
    #[inline]
    fn clone(&self) -> UnitPetarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetarayls {
    #[inline]
    fn eq(&self, other: &UnitPetarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetarayls {
    fn default() -> Self {
        UnitPetarayls
    }
}
impl Add<UnitPetarayls> for UnitPetarayls {
    type Output = UnitPetarayls;
    #[inline]
    fn add(self, _: UnitPetarayls) -> Self::Output {
        UnitPetarayls
    }
}
impl AddAssign<UnitPetarayls> for UnitPetarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitPetarayls) {}
}
impl Sub<UnitPetarayls> for UnitPetarayls {
    type Output = UnitPetarayls;
    #[inline]
    fn sub(self, _: UnitPetarayls) -> Self::Output {
        UnitPetarayls
    }
}
impl SubAssign<UnitPetarayls> for UnitPetarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetarayls) {}
}
pub struct UnitPetaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaraylsMul {
    #[inline]
    fn clone(&self) -> UnitPetaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitPetaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaraylsMul> for i8 {
    type Output = Quantity<i8, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for i16 {
    type Output = Quantity<i16, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for i32 {
    type Output = Quantity<i32, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for i64 {
    type Output = Quantity<i64, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for i128 {
    type Output = Quantity<i128, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for isize {
    type Output = Quantity<isize, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for u8 {
    type Output = Quantity<u8, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for u16 {
    type Output = Quantity<u16, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for u32 {
    type Output = Quantity<u32, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for u64 {
    type Output = Quantity<u64, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for u128 {
    type Output = Quantity<u128, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for usize {
    type Output = Quantity<usize, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for f32 {
    type Output = Quantity<f32, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
impl Mul<UnitPetaraylsMul> for f64 {
    type Output = Quantity<f64, UnitPetarayls>;
    fn mul(self, _: UnitPetaraylsMul) -> Self::Output {
        Quantity::new(self, UnitPetarayls)
    }
}
pub struct UnitTerarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerarayls {
    #[inline]
    fn clone(&self) -> UnitTerarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerarayls {
    #[inline]
    fn eq(&self, other: &UnitTerarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerarayls {
    fn default() -> Self {
        UnitTerarayls
    }
}
impl Add<UnitTerarayls> for UnitTerarayls {
    type Output = UnitTerarayls;
    #[inline]
    fn add(self, _: UnitTerarayls) -> Self::Output {
        UnitTerarayls
    }
}
impl AddAssign<UnitTerarayls> for UnitTerarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitTerarayls) {}
}
impl Sub<UnitTerarayls> for UnitTerarayls {
    type Output = UnitTerarayls;
    #[inline]
    fn sub(self, _: UnitTerarayls) -> Self::Output {
        UnitTerarayls
    }
}
impl SubAssign<UnitTerarayls> for UnitTerarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerarayls) {}
}
pub struct UnitTeraraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraraylsMul {
    #[inline]
    fn clone(&self) -> UnitTeraraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraraylsMul {
    #[inline]
    fn eq(&self, other: &UnitTeraraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraraylsMul> for i8 {
    type Output = Quantity<i8, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for i16 {
    type Output = Quantity<i16, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for i32 {
    type Output = Quantity<i32, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for i64 {
    type Output = Quantity<i64, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for i128 {
    type Output = Quantity<i128, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for isize {
    type Output = Quantity<isize, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for u8 {
    type Output = Quantity<u8, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for u16 {
    type Output = Quantity<u16, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for u32 {
    type Output = Quantity<u32, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for u64 {
    type Output = Quantity<u64, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for u128 {
    type Output = Quantity<u128, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for usize {
    type Output = Quantity<usize, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for f32 {
    type Output = Quantity<f32, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
impl Mul<UnitTeraraylsMul> for f64 {
    type Output = Quantity<f64, UnitTerarayls>;
    fn mul(self, _: UnitTeraraylsMul) -> Self::Output {
        Quantity::new(self, UnitTerarayls)
    }
}
pub struct UnitGigarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigarayls {
    #[inline]
    fn clone(&self) -> UnitGigarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigarayls {
    #[inline]
    fn eq(&self, other: &UnitGigarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigarayls {
    fn default() -> Self {
        UnitGigarayls
    }
}
impl Add<UnitGigarayls> for UnitGigarayls {
    type Output = UnitGigarayls;
    #[inline]
    fn add(self, _: UnitGigarayls) -> Self::Output {
        UnitGigarayls
    }
}
impl AddAssign<UnitGigarayls> for UnitGigarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitGigarayls) {}
}
impl Sub<UnitGigarayls> for UnitGigarayls {
    type Output = UnitGigarayls;
    #[inline]
    fn sub(self, _: UnitGigarayls) -> Self::Output {
        UnitGigarayls
    }
}
impl SubAssign<UnitGigarayls> for UnitGigarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigarayls) {}
}
pub struct UnitGigaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaraylsMul {
    #[inline]
    fn clone(&self) -> UnitGigaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitGigaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaraylsMul> for i8 {
    type Output = Quantity<i8, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for i16 {
    type Output = Quantity<i16, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for i32 {
    type Output = Quantity<i32, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for i64 {
    type Output = Quantity<i64, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for i128 {
    type Output = Quantity<i128, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for isize {
    type Output = Quantity<isize, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for u8 {
    type Output = Quantity<u8, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for u16 {
    type Output = Quantity<u16, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for u32 {
    type Output = Quantity<u32, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for u64 {
    type Output = Quantity<u64, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for u128 {
    type Output = Quantity<u128, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for usize {
    type Output = Quantity<usize, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for f32 {
    type Output = Quantity<f32, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
impl Mul<UnitGigaraylsMul> for f64 {
    type Output = Quantity<f64, UnitGigarayls>;
    fn mul(self, _: UnitGigaraylsMul) -> Self::Output {
        Quantity::new(self, UnitGigarayls)
    }
}
pub struct UnitMegarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegarayls {
    #[inline]
    fn clone(&self) -> UnitMegarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegarayls {
    #[inline]
    fn eq(&self, other: &UnitMegarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegarayls {
    fn default() -> Self {
        UnitMegarayls
    }
}
impl Add<UnitMegarayls> for UnitMegarayls {
    type Output = UnitMegarayls;
    #[inline]
    fn add(self, _: UnitMegarayls) -> Self::Output {
        UnitMegarayls
    }
}
impl AddAssign<UnitMegarayls> for UnitMegarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitMegarayls) {}
}
impl Sub<UnitMegarayls> for UnitMegarayls {
    type Output = UnitMegarayls;
    #[inline]
    fn sub(self, _: UnitMegarayls) -> Self::Output {
        UnitMegarayls
    }
}
impl SubAssign<UnitMegarayls> for UnitMegarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegarayls) {}
}
pub struct UnitMegaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaraylsMul {
    #[inline]
    fn clone(&self) -> UnitMegaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitMegaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaraylsMul> for i8 {
    type Output = Quantity<i8, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for i16 {
    type Output = Quantity<i16, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for i32 {
    type Output = Quantity<i32, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for i64 {
    type Output = Quantity<i64, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for i128 {
    type Output = Quantity<i128, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for isize {
    type Output = Quantity<isize, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for u8 {
    type Output = Quantity<u8, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for u16 {
    type Output = Quantity<u16, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for u32 {
    type Output = Quantity<u32, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for u64 {
    type Output = Quantity<u64, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for u128 {
    type Output = Quantity<u128, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for usize {
    type Output = Quantity<usize, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for f32 {
    type Output = Quantity<f32, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
impl Mul<UnitMegaraylsMul> for f64 {
    type Output = Quantity<f64, UnitMegarayls>;
    fn mul(self, _: UnitMegaraylsMul) -> Self::Output {
        Quantity::new(self, UnitMegarayls)
    }
}
pub struct UnitKilorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilorayls {
    #[inline]
    fn clone(&self) -> UnitKilorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilorayls {
    #[inline]
    fn eq(&self, other: &UnitKilorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilorayls {
    fn default() -> Self {
        UnitKilorayls
    }
}
impl Add<UnitKilorayls> for UnitKilorayls {
    type Output = UnitKilorayls;
    #[inline]
    fn add(self, _: UnitKilorayls) -> Self::Output {
        UnitKilorayls
    }
}
impl AddAssign<UnitKilorayls> for UnitKilorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitKilorayls) {}
}
impl Sub<UnitKilorayls> for UnitKilorayls {
    type Output = UnitKilorayls;
    #[inline]
    fn sub(self, _: UnitKilorayls) -> Self::Output {
        UnitKilorayls
    }
}
impl SubAssign<UnitKilorayls> for UnitKilorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilorayls) {}
}
pub struct UnitKiloraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloraylsMul {
    #[inline]
    fn clone(&self) -> UnitKiloraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloraylsMul {
    #[inline]
    fn eq(&self, other: &UnitKiloraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloraylsMul> for i8 {
    type Output = Quantity<i8, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for i16 {
    type Output = Quantity<i16, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for i32 {
    type Output = Quantity<i32, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for i64 {
    type Output = Quantity<i64, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for i128 {
    type Output = Quantity<i128, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for isize {
    type Output = Quantity<isize, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for u8 {
    type Output = Quantity<u8, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for u16 {
    type Output = Quantity<u16, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for u32 {
    type Output = Quantity<u32, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for u64 {
    type Output = Quantity<u64, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for u128 {
    type Output = Quantity<u128, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for usize {
    type Output = Quantity<usize, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for f32 {
    type Output = Quantity<f32, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
impl Mul<UnitKiloraylsMul> for f64 {
    type Output = Quantity<f64, UnitKilorayls>;
    fn mul(self, _: UnitKiloraylsMul) -> Self::Output {
        Quantity::new(self, UnitKilorayls)
    }
}
pub struct UnitHectorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectorayls {
    #[inline]
    fn clone(&self) -> UnitHectorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectorayls {
    #[inline]
    fn eq(&self, other: &UnitHectorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectorayls {
    fn default() -> Self {
        UnitHectorayls
    }
}
impl Add<UnitHectorayls> for UnitHectorayls {
    type Output = UnitHectorayls;
    #[inline]
    fn add(self, _: UnitHectorayls) -> Self::Output {
        UnitHectorayls
    }
}
impl AddAssign<UnitHectorayls> for UnitHectorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitHectorayls) {}
}
impl Sub<UnitHectorayls> for UnitHectorayls {
    type Output = UnitHectorayls;
    #[inline]
    fn sub(self, _: UnitHectorayls) -> Self::Output {
        UnitHectorayls
    }
}
impl SubAssign<UnitHectorayls> for UnitHectorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectorayls) {}
}
pub struct UnitHectoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoraylsMul {
    #[inline]
    fn clone(&self) -> UnitHectoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitHectoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoraylsMul> for i8 {
    type Output = Quantity<i8, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for i16 {
    type Output = Quantity<i16, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for i32 {
    type Output = Quantity<i32, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for i64 {
    type Output = Quantity<i64, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for i128 {
    type Output = Quantity<i128, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for isize {
    type Output = Quantity<isize, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for u8 {
    type Output = Quantity<u8, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for u16 {
    type Output = Quantity<u16, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for u32 {
    type Output = Quantity<u32, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for u64 {
    type Output = Quantity<u64, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for u128 {
    type Output = Quantity<u128, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for usize {
    type Output = Quantity<usize, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for f32 {
    type Output = Quantity<f32, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
impl Mul<UnitHectoraylsMul> for f64 {
    type Output = Quantity<f64, UnitHectorayls>;
    fn mul(self, _: UnitHectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitHectorayls)
    }
}
pub struct UnitDecarayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecarayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecarayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecarayls {
    #[inline]
    fn clone(&self) -> UnitDecarayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecarayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecarayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecarayls {
    #[inline]
    fn eq(&self, other: &UnitDecarayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecarayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecarayls {
    fn default() -> Self {
        UnitDecarayls
    }
}
impl Add<UnitDecarayls> for UnitDecarayls {
    type Output = UnitDecarayls;
    #[inline]
    fn add(self, _: UnitDecarayls) -> Self::Output {
        UnitDecarayls
    }
}
impl AddAssign<UnitDecarayls> for UnitDecarayls {
    #[inline]
    fn add_assign(&mut self, _: UnitDecarayls) {}
}
impl Sub<UnitDecarayls> for UnitDecarayls {
    type Output = UnitDecarayls;
    #[inline]
    fn sub(self, _: UnitDecarayls) -> Self::Output {
        UnitDecarayls
    }
}
impl SubAssign<UnitDecarayls> for UnitDecarayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecarayls) {}
}
pub struct UnitDecaraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaraylsMul {
    #[inline]
    fn clone(&self) -> UnitDecaraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaraylsMul {
    #[inline]
    fn eq(&self, other: &UnitDecaraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaraylsMul> for i8 {
    type Output = Quantity<i8, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for i16 {
    type Output = Quantity<i16, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for i32 {
    type Output = Quantity<i32, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for i64 {
    type Output = Quantity<i64, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for i128 {
    type Output = Quantity<i128, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for isize {
    type Output = Quantity<isize, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for u8 {
    type Output = Quantity<u8, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for u16 {
    type Output = Quantity<u16, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for u32 {
    type Output = Quantity<u32, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for u64 {
    type Output = Quantity<u64, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for u128 {
    type Output = Quantity<u128, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for usize {
    type Output = Quantity<usize, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for f32 {
    type Output = Quantity<f32, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
impl Mul<UnitDecaraylsMul> for f64 {
    type Output = Quantity<f64, UnitDecarayls>;
    fn mul(self, _: UnitDecaraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecarayls)
    }
}
pub struct UnitDecirayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecirayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecirayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecirayls {
    #[inline]
    fn clone(&self) -> UnitDecirayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecirayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecirayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecirayls {
    #[inline]
    fn eq(&self, other: &UnitDecirayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecirayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecirayls {
    fn default() -> Self {
        UnitDecirayls
    }
}
impl Add<UnitDecirayls> for UnitDecirayls {
    type Output = UnitDecirayls;
    #[inline]
    fn add(self, _: UnitDecirayls) -> Self::Output {
        UnitDecirayls
    }
}
impl AddAssign<UnitDecirayls> for UnitDecirayls {
    #[inline]
    fn add_assign(&mut self, _: UnitDecirayls) {}
}
impl Sub<UnitDecirayls> for UnitDecirayls {
    type Output = UnitDecirayls;
    #[inline]
    fn sub(self, _: UnitDecirayls) -> Self::Output {
        UnitDecirayls
    }
}
impl SubAssign<UnitDecirayls> for UnitDecirayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecirayls) {}
}
pub struct UnitDeciraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciraylsMul {
    #[inline]
    fn clone(&self) -> UnitDeciraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciraylsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciraylsMul> for i8 {
    type Output = Quantity<i8, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for i16 {
    type Output = Quantity<i16, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for i32 {
    type Output = Quantity<i32, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for i64 {
    type Output = Quantity<i64, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for i128 {
    type Output = Quantity<i128, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for isize {
    type Output = Quantity<isize, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for u8 {
    type Output = Quantity<u8, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for u16 {
    type Output = Quantity<u16, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for u32 {
    type Output = Quantity<u32, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for u64 {
    type Output = Quantity<u64, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for u128 {
    type Output = Quantity<u128, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for usize {
    type Output = Quantity<usize, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for f32 {
    type Output = Quantity<f32, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
impl Mul<UnitDeciraylsMul> for f64 {
    type Output = Quantity<f64, UnitDecirayls>;
    fn mul(self, _: UnitDeciraylsMul) -> Self::Output {
        Quantity::new(self, UnitDecirayls)
    }
}
pub struct UnitCentirayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentirayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentirayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentirayls {
    #[inline]
    fn clone(&self) -> UnitCentirayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentirayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentirayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentirayls {
    #[inline]
    fn eq(&self, other: &UnitCentirayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentirayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentirayls {
    fn default() -> Self {
        UnitCentirayls
    }
}
impl Add<UnitCentirayls> for UnitCentirayls {
    type Output = UnitCentirayls;
    #[inline]
    fn add(self, _: UnitCentirayls) -> Self::Output {
        UnitCentirayls
    }
}
impl AddAssign<UnitCentirayls> for UnitCentirayls {
    #[inline]
    fn add_assign(&mut self, _: UnitCentirayls) {}
}
impl Sub<UnitCentirayls> for UnitCentirayls {
    type Output = UnitCentirayls;
    #[inline]
    fn sub(self, _: UnitCentirayls) -> Self::Output {
        UnitCentirayls
    }
}
impl SubAssign<UnitCentirayls> for UnitCentirayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentirayls) {}
}
pub struct UnitCentiraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiraylsMul {
    #[inline]
    fn clone(&self) -> UnitCentiraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiraylsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiraylsMul> for i8 {
    type Output = Quantity<i8, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for i16 {
    type Output = Quantity<i16, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for i32 {
    type Output = Quantity<i32, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for i64 {
    type Output = Quantity<i64, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for i128 {
    type Output = Quantity<i128, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for isize {
    type Output = Quantity<isize, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for u8 {
    type Output = Quantity<u8, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for u16 {
    type Output = Quantity<u16, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for u32 {
    type Output = Quantity<u32, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for u64 {
    type Output = Quantity<u64, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for u128 {
    type Output = Quantity<u128, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for usize {
    type Output = Quantity<usize, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for f32 {
    type Output = Quantity<f32, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
impl Mul<UnitCentiraylsMul> for f64 {
    type Output = Quantity<f64, UnitCentirayls>;
    fn mul(self, _: UnitCentiraylsMul) -> Self::Output {
        Quantity::new(self, UnitCentirayls)
    }
}
pub struct UnitMillirayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillirayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillirayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillirayls {
    #[inline]
    fn clone(&self) -> UnitMillirayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillirayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillirayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillirayls {
    #[inline]
    fn eq(&self, other: &UnitMillirayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillirayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillirayls {
    fn default() -> Self {
        UnitMillirayls
    }
}
impl Add<UnitMillirayls> for UnitMillirayls {
    type Output = UnitMillirayls;
    #[inline]
    fn add(self, _: UnitMillirayls) -> Self::Output {
        UnitMillirayls
    }
}
impl AddAssign<UnitMillirayls> for UnitMillirayls {
    #[inline]
    fn add_assign(&mut self, _: UnitMillirayls) {}
}
impl Sub<UnitMillirayls> for UnitMillirayls {
    type Output = UnitMillirayls;
    #[inline]
    fn sub(self, _: UnitMillirayls) -> Self::Output {
        UnitMillirayls
    }
}
impl SubAssign<UnitMillirayls> for UnitMillirayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillirayls) {}
}
pub struct UnitMilliraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliraylsMul {
    #[inline]
    fn clone(&self) -> UnitMilliraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliraylsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliraylsMul> for i8 {
    type Output = Quantity<i8, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for i16 {
    type Output = Quantity<i16, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for i32 {
    type Output = Quantity<i32, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for i64 {
    type Output = Quantity<i64, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for i128 {
    type Output = Quantity<i128, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for isize {
    type Output = Quantity<isize, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for u8 {
    type Output = Quantity<u8, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for u16 {
    type Output = Quantity<u16, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for u32 {
    type Output = Quantity<u32, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for u64 {
    type Output = Quantity<u64, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for u128 {
    type Output = Quantity<u128, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for usize {
    type Output = Quantity<usize, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for f32 {
    type Output = Quantity<f32, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
impl Mul<UnitMilliraylsMul> for f64 {
    type Output = Quantity<f64, UnitMillirayls>;
    fn mul(self, _: UnitMilliraylsMul) -> Self::Output {
        Quantity::new(self, UnitMillirayls)
    }
}
pub struct UnitMicrorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrorayls {
    #[inline]
    fn clone(&self) -> UnitMicrorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrorayls {
    #[inline]
    fn eq(&self, other: &UnitMicrorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrorayls {
    fn default() -> Self {
        UnitMicrorayls
    }
}
impl Add<UnitMicrorayls> for UnitMicrorayls {
    type Output = UnitMicrorayls;
    #[inline]
    fn add(self, _: UnitMicrorayls) -> Self::Output {
        UnitMicrorayls
    }
}
impl AddAssign<UnitMicrorayls> for UnitMicrorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrorayls) {}
}
impl Sub<UnitMicrorayls> for UnitMicrorayls {
    type Output = UnitMicrorayls;
    #[inline]
    fn sub(self, _: UnitMicrorayls) -> Self::Output {
        UnitMicrorayls
    }
}
impl SubAssign<UnitMicrorayls> for UnitMicrorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrorayls) {}
}
pub struct UnitMicroraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroraylsMul {
    #[inline]
    fn clone(&self) -> UnitMicroraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroraylsMul {
    #[inline]
    fn eq(&self, other: &UnitMicroraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroraylsMul> for i8 {
    type Output = Quantity<i8, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for i16 {
    type Output = Quantity<i16, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for i32 {
    type Output = Quantity<i32, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for i64 {
    type Output = Quantity<i64, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for i128 {
    type Output = Quantity<i128, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for isize {
    type Output = Quantity<isize, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for u8 {
    type Output = Quantity<u8, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for u16 {
    type Output = Quantity<u16, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for u32 {
    type Output = Quantity<u32, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for u64 {
    type Output = Quantity<u64, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for u128 {
    type Output = Quantity<u128, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for usize {
    type Output = Quantity<usize, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for f32 {
    type Output = Quantity<f32, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
impl Mul<UnitMicroraylsMul> for f64 {
    type Output = Quantity<f64, UnitMicrorayls>;
    fn mul(self, _: UnitMicroraylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrorayls)
    }
}
pub struct UnitNanorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanorayls {
    #[inline]
    fn clone(&self) -> UnitNanorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanorayls {
    #[inline]
    fn eq(&self, other: &UnitNanorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanorayls {
    fn default() -> Self {
        UnitNanorayls
    }
}
impl Add<UnitNanorayls> for UnitNanorayls {
    type Output = UnitNanorayls;
    #[inline]
    fn add(self, _: UnitNanorayls) -> Self::Output {
        UnitNanorayls
    }
}
impl AddAssign<UnitNanorayls> for UnitNanorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitNanorayls) {}
}
impl Sub<UnitNanorayls> for UnitNanorayls {
    type Output = UnitNanorayls;
    #[inline]
    fn sub(self, _: UnitNanorayls) -> Self::Output {
        UnitNanorayls
    }
}
impl SubAssign<UnitNanorayls> for UnitNanorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanorayls) {}
}
pub struct UnitNanoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoraylsMul {
    #[inline]
    fn clone(&self) -> UnitNanoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitNanoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoraylsMul> for i8 {
    type Output = Quantity<i8, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for i16 {
    type Output = Quantity<i16, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for i32 {
    type Output = Quantity<i32, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for i64 {
    type Output = Quantity<i64, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for i128 {
    type Output = Quantity<i128, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for isize {
    type Output = Quantity<isize, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for u8 {
    type Output = Quantity<u8, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for u16 {
    type Output = Quantity<u16, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for u32 {
    type Output = Quantity<u32, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for u64 {
    type Output = Quantity<u64, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for u128 {
    type Output = Quantity<u128, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for usize {
    type Output = Quantity<usize, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for f32 {
    type Output = Quantity<f32, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
impl Mul<UnitNanoraylsMul> for f64 {
    type Output = Quantity<f64, UnitNanorayls>;
    fn mul(self, _: UnitNanoraylsMul) -> Self::Output {
        Quantity::new(self, UnitNanorayls)
    }
}
pub struct UnitPicorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicorayls {
    #[inline]
    fn clone(&self) -> UnitPicorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicorayls {
    #[inline]
    fn eq(&self, other: &UnitPicorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicorayls {
    fn default() -> Self {
        UnitPicorayls
    }
}
impl Add<UnitPicorayls> for UnitPicorayls {
    type Output = UnitPicorayls;
    #[inline]
    fn add(self, _: UnitPicorayls) -> Self::Output {
        UnitPicorayls
    }
}
impl AddAssign<UnitPicorayls> for UnitPicorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitPicorayls) {}
}
impl Sub<UnitPicorayls> for UnitPicorayls {
    type Output = UnitPicorayls;
    #[inline]
    fn sub(self, _: UnitPicorayls) -> Self::Output {
        UnitPicorayls
    }
}
impl SubAssign<UnitPicorayls> for UnitPicorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicorayls) {}
}
pub struct UnitPicoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoraylsMul {
    #[inline]
    fn clone(&self) -> UnitPicoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitPicoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoraylsMul> for i8 {
    type Output = Quantity<i8, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for i16 {
    type Output = Quantity<i16, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for i32 {
    type Output = Quantity<i32, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for i64 {
    type Output = Quantity<i64, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for i128 {
    type Output = Quantity<i128, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for isize {
    type Output = Quantity<isize, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for u8 {
    type Output = Quantity<u8, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for u16 {
    type Output = Quantity<u16, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for u32 {
    type Output = Quantity<u32, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for u64 {
    type Output = Quantity<u64, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for u128 {
    type Output = Quantity<u128, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for usize {
    type Output = Quantity<usize, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for f32 {
    type Output = Quantity<f32, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
impl Mul<UnitPicoraylsMul> for f64 {
    type Output = Quantity<f64, UnitPicorayls>;
    fn mul(self, _: UnitPicoraylsMul) -> Self::Output {
        Quantity::new(self, UnitPicorayls)
    }
}
pub struct UnitFemtorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtorayls {
    #[inline]
    fn clone(&self) -> UnitFemtorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtorayls {
    #[inline]
    fn eq(&self, other: &UnitFemtorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtorayls {
    fn default() -> Self {
        UnitFemtorayls
    }
}
impl Add<UnitFemtorayls> for UnitFemtorayls {
    type Output = UnitFemtorayls;
    #[inline]
    fn add(self, _: UnitFemtorayls) -> Self::Output {
        UnitFemtorayls
    }
}
impl AddAssign<UnitFemtorayls> for UnitFemtorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtorayls) {}
}
impl Sub<UnitFemtorayls> for UnitFemtorayls {
    type Output = UnitFemtorayls;
    #[inline]
    fn sub(self, _: UnitFemtorayls) -> Self::Output {
        UnitFemtorayls
    }
}
impl SubAssign<UnitFemtorayls> for UnitFemtorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtorayls) {}
}
pub struct UnitFemtoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoraylsMul {
    #[inline]
    fn clone(&self) -> UnitFemtoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoraylsMul> for i8 {
    type Output = Quantity<i8, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for i16 {
    type Output = Quantity<i16, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for i32 {
    type Output = Quantity<i32, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for i64 {
    type Output = Quantity<i64, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for i128 {
    type Output = Quantity<i128, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for isize {
    type Output = Quantity<isize, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for u8 {
    type Output = Quantity<u8, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for u16 {
    type Output = Quantity<u16, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for u32 {
    type Output = Quantity<u32, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for u64 {
    type Output = Quantity<u64, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for u128 {
    type Output = Quantity<u128, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for usize {
    type Output = Quantity<usize, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for f32 {
    type Output = Quantity<f32, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
impl Mul<UnitFemtoraylsMul> for f64 {
    type Output = Quantity<f64, UnitFemtorayls>;
    fn mul(self, _: UnitFemtoraylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtorayls)
    }
}
pub struct UnitAttorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttorayls {
    #[inline]
    fn clone(&self) -> UnitAttorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttorayls {
    #[inline]
    fn eq(&self, other: &UnitAttorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttorayls {
    fn default() -> Self {
        UnitAttorayls
    }
}
impl Add<UnitAttorayls> for UnitAttorayls {
    type Output = UnitAttorayls;
    #[inline]
    fn add(self, _: UnitAttorayls) -> Self::Output {
        UnitAttorayls
    }
}
impl AddAssign<UnitAttorayls> for UnitAttorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitAttorayls) {}
}
impl Sub<UnitAttorayls> for UnitAttorayls {
    type Output = UnitAttorayls;
    #[inline]
    fn sub(self, _: UnitAttorayls) -> Self::Output {
        UnitAttorayls
    }
}
impl SubAssign<UnitAttorayls> for UnitAttorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttorayls) {}
}
pub struct UnitAttoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoraylsMul {
    #[inline]
    fn clone(&self) -> UnitAttoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitAttoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoraylsMul> for i8 {
    type Output = Quantity<i8, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for i16 {
    type Output = Quantity<i16, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for i32 {
    type Output = Quantity<i32, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for i64 {
    type Output = Quantity<i64, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for i128 {
    type Output = Quantity<i128, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for isize {
    type Output = Quantity<isize, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for u8 {
    type Output = Quantity<u8, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for u16 {
    type Output = Quantity<u16, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for u32 {
    type Output = Quantity<u32, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for u64 {
    type Output = Quantity<u64, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for u128 {
    type Output = Quantity<u128, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for usize {
    type Output = Quantity<usize, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for f32 {
    type Output = Quantity<f32, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
impl Mul<UnitAttoraylsMul> for f64 {
    type Output = Quantity<f64, UnitAttorayls>;
    fn mul(self, _: UnitAttoraylsMul) -> Self::Output {
        Quantity::new(self, UnitAttorayls)
    }
}
pub struct UnitZeptorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptorayls {
    #[inline]
    fn clone(&self) -> UnitZeptorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptorayls {
    #[inline]
    fn eq(&self, other: &UnitZeptorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptorayls {
    fn default() -> Self {
        UnitZeptorayls
    }
}
impl Add<UnitZeptorayls> for UnitZeptorayls {
    type Output = UnitZeptorayls;
    #[inline]
    fn add(self, _: UnitZeptorayls) -> Self::Output {
        UnitZeptorayls
    }
}
impl AddAssign<UnitZeptorayls> for UnitZeptorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptorayls) {}
}
impl Sub<UnitZeptorayls> for UnitZeptorayls {
    type Output = UnitZeptorayls;
    #[inline]
    fn sub(self, _: UnitZeptorayls) -> Self::Output {
        UnitZeptorayls
    }
}
impl SubAssign<UnitZeptorayls> for UnitZeptorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptorayls) {}
}
pub struct UnitZeptoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoraylsMul {
    #[inline]
    fn clone(&self) -> UnitZeptoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoraylsMul> for i8 {
    type Output = Quantity<i8, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for i16 {
    type Output = Quantity<i16, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for i32 {
    type Output = Quantity<i32, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for i64 {
    type Output = Quantity<i64, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for i128 {
    type Output = Quantity<i128, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for isize {
    type Output = Quantity<isize, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for u8 {
    type Output = Quantity<u8, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for u16 {
    type Output = Quantity<u16, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for u32 {
    type Output = Quantity<u32, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for u64 {
    type Output = Quantity<u64, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for u128 {
    type Output = Quantity<u128, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for usize {
    type Output = Quantity<usize, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for f32 {
    type Output = Quantity<f32, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
impl Mul<UnitZeptoraylsMul> for f64 {
    type Output = Quantity<f64, UnitZeptorayls>;
    fn mul(self, _: UnitZeptoraylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptorayls)
    }
}
pub struct UnitYoctorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctorayls {
    #[inline]
    fn clone(&self) -> UnitYoctorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctorayls {
    #[inline]
    fn eq(&self, other: &UnitYoctorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctorayls {
    fn default() -> Self {
        UnitYoctorayls
    }
}
impl Add<UnitYoctorayls> for UnitYoctorayls {
    type Output = UnitYoctorayls;
    #[inline]
    fn add(self, _: UnitYoctorayls) -> Self::Output {
        UnitYoctorayls
    }
}
impl AddAssign<UnitYoctorayls> for UnitYoctorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctorayls) {}
}
impl Sub<UnitYoctorayls> for UnitYoctorayls {
    type Output = UnitYoctorayls;
    #[inline]
    fn sub(self, _: UnitYoctorayls) -> Self::Output {
        UnitYoctorayls
    }
}
impl SubAssign<UnitYoctorayls> for UnitYoctorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctorayls) {}
}
pub struct UnitYoctoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoraylsMul {
    #[inline]
    fn clone(&self) -> UnitYoctoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoraylsMul> for i8 {
    type Output = Quantity<i8, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for i16 {
    type Output = Quantity<i16, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for i32 {
    type Output = Quantity<i32, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for i64 {
    type Output = Quantity<i64, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for i128 {
    type Output = Quantity<i128, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for isize {
    type Output = Quantity<isize, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for u8 {
    type Output = Quantity<u8, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for u16 {
    type Output = Quantity<u16, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for u32 {
    type Output = Quantity<u32, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for u64 {
    type Output = Quantity<u64, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for u128 {
    type Output = Quantity<u128, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for usize {
    type Output = Quantity<usize, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for f32 {
    type Output = Quantity<f32, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
impl Mul<UnitYoctoraylsMul> for f64 {
    type Output = Quantity<f64, UnitYoctorayls>;
    fn mul(self, _: UnitYoctoraylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctorayls)
    }
}
pub struct UnitRontorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontorayls {
    #[inline]
    fn clone(&self) -> UnitRontorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontorayls {
    #[inline]
    fn eq(&self, other: &UnitRontorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontorayls {
    fn default() -> Self {
        UnitRontorayls
    }
}
impl Add<UnitRontorayls> for UnitRontorayls {
    type Output = UnitRontorayls;
    #[inline]
    fn add(self, _: UnitRontorayls) -> Self::Output {
        UnitRontorayls
    }
}
impl AddAssign<UnitRontorayls> for UnitRontorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitRontorayls) {}
}
impl Sub<UnitRontorayls> for UnitRontorayls {
    type Output = UnitRontorayls;
    #[inline]
    fn sub(self, _: UnitRontorayls) -> Self::Output {
        UnitRontorayls
    }
}
impl SubAssign<UnitRontorayls> for UnitRontorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontorayls) {}
}
pub struct UnitRontoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoraylsMul {
    #[inline]
    fn clone(&self) -> UnitRontoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitRontoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoraylsMul> for i8 {
    type Output = Quantity<i8, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for i16 {
    type Output = Quantity<i16, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for i32 {
    type Output = Quantity<i32, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for i64 {
    type Output = Quantity<i64, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for i128 {
    type Output = Quantity<i128, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for isize {
    type Output = Quantity<isize, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for u8 {
    type Output = Quantity<u8, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for u16 {
    type Output = Quantity<u16, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for u32 {
    type Output = Quantity<u32, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for u64 {
    type Output = Quantity<u64, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for u128 {
    type Output = Quantity<u128, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for usize {
    type Output = Quantity<usize, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for f32 {
    type Output = Quantity<f32, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
impl Mul<UnitRontoraylsMul> for f64 {
    type Output = Quantity<f64, UnitRontorayls>;
    fn mul(self, _: UnitRontoraylsMul) -> Self::Output {
        Quantity::new(self, UnitRontorayls)
    }
}
pub struct UnitQuectorayls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectorayls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectorayls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectorayls {
    #[inline]
    fn clone(&self) -> UnitQuectorayls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectorayls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectorayls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectorayls {
    #[inline]
    fn eq(&self, other: &UnitQuectorayls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectorayls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectorayls {
    fn default() -> Self {
        UnitQuectorayls
    }
}
impl Add<UnitQuectorayls> for UnitQuectorayls {
    type Output = UnitQuectorayls;
    #[inline]
    fn add(self, _: UnitQuectorayls) -> Self::Output {
        UnitQuectorayls
    }
}
impl AddAssign<UnitQuectorayls> for UnitQuectorayls {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectorayls) {}
}
impl Sub<UnitQuectorayls> for UnitQuectorayls {
    type Output = UnitQuectorayls;
    #[inline]
    fn sub(self, _: UnitQuectorayls) -> Self::Output {
        UnitQuectorayls
    }
}
impl SubAssign<UnitQuectorayls> for UnitQuectorayls {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectorayls) {}
}
pub struct UnitQuectoraylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoraylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoraylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoraylsMul {
    #[inline]
    fn clone(&self) -> UnitQuectoraylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoraylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoraylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoraylsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoraylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoraylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoraylsMul> for i8 {
    type Output = Quantity<i8, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for i16 {
    type Output = Quantity<i16, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for i32 {
    type Output = Quantity<i32, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for i64 {
    type Output = Quantity<i64, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for i128 {
    type Output = Quantity<i128, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for isize {
    type Output = Quantity<isize, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for u8 {
    type Output = Quantity<u8, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for u16 {
    type Output = Quantity<u16, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for u32 {
    type Output = Quantity<u32, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for u64 {
    type Output = Quantity<u64, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for u128 {
    type Output = Quantity<u128, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for usize {
    type Output = Quantity<usize, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for f32 {
    type Output = Quantity<f32, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
impl Mul<UnitQuectoraylsMul> for f64 {
    type Output = Quantity<f64, UnitQuectorayls>;
    fn mul(self, _: UnitQuectoraylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectorayls)
    }
}
pub type Rayls<T> = Quantity<T, UnitRayls>;
#[allow(non_upper_case_globals)]
pub static Rayls: UnitRaylsMul = UnitRaylsMul;
pub type Quettarayls<T> = Quantity<T, UnitQuettarayls>;
#[allow(non_upper_case_globals)]
pub static Quettarayls: UnitQuettaraylsMul = UnitQuettaraylsMul;
pub type Ronnarayls<T> = Quantity<T, UnitRonnarayls>;
#[allow(non_upper_case_globals)]
pub static Ronnarayls: UnitRonnaraylsMul = UnitRonnaraylsMul;
pub type Yottarayls<T> = Quantity<T, UnitYottarayls>;
#[allow(non_upper_case_globals)]
pub static Yottarayls: UnitYottaraylsMul = UnitYottaraylsMul;
pub type Zettarayls<T> = Quantity<T, UnitZettarayls>;
#[allow(non_upper_case_globals)]
pub static Zettarayls: UnitZettaraylsMul = UnitZettaraylsMul;
pub type Exarayls<T> = Quantity<T, UnitExarayls>;
#[allow(non_upper_case_globals)]
pub static Exarayls: UnitExaraylsMul = UnitExaraylsMul;
pub type Petarayls<T> = Quantity<T, UnitPetarayls>;
#[allow(non_upper_case_globals)]
pub static Petarayls: UnitPetaraylsMul = UnitPetaraylsMul;
pub type Terarayls<T> = Quantity<T, UnitTerarayls>;
#[allow(non_upper_case_globals)]
pub static Terarayls: UnitTeraraylsMul = UnitTeraraylsMul;
pub type Gigarayls<T> = Quantity<T, UnitGigarayls>;
#[allow(non_upper_case_globals)]
pub static Gigarayls: UnitGigaraylsMul = UnitGigaraylsMul;
pub type Megarayls<T> = Quantity<T, UnitMegarayls>;
#[allow(non_upper_case_globals)]
pub static Megarayls: UnitMegaraylsMul = UnitMegaraylsMul;
pub type Kilorayls<T> = Quantity<T, UnitKilorayls>;
#[allow(non_upper_case_globals)]
pub static Kilorayls: UnitKiloraylsMul = UnitKiloraylsMul;
pub type Hectorayls<T> = Quantity<T, UnitHectorayls>;
#[allow(non_upper_case_globals)]
pub static Hectorayls: UnitHectoraylsMul = UnitHectoraylsMul;
pub type Decarayls<T> = Quantity<T, UnitDecarayls>;
#[allow(non_upper_case_globals)]
pub static Decarayls: UnitDecaraylsMul = UnitDecaraylsMul;
pub type Decirayls<T> = Quantity<T, UnitDecirayls>;
#[allow(non_upper_case_globals)]
pub static Decirayls: UnitDeciraylsMul = UnitDeciraylsMul;
pub type Centirayls<T> = Quantity<T, UnitCentirayls>;
#[allow(non_upper_case_globals)]
pub static Centirayls: UnitCentiraylsMul = UnitCentiraylsMul;
pub type Millirayls<T> = Quantity<T, UnitMillirayls>;
#[allow(non_upper_case_globals)]
pub static Millirayls: UnitMilliraylsMul = UnitMilliraylsMul;
pub type Microrayls<T> = Quantity<T, UnitMicrorayls>;
#[allow(non_upper_case_globals)]
pub static Microrayls: UnitMicroraylsMul = UnitMicroraylsMul;
pub type Nanorayls<T> = Quantity<T, UnitNanorayls>;
#[allow(non_upper_case_globals)]
pub static Nanorayls: UnitNanoraylsMul = UnitNanoraylsMul;
pub type Picorayls<T> = Quantity<T, UnitPicorayls>;
#[allow(non_upper_case_globals)]
pub static Picorayls: UnitPicoraylsMul = UnitPicoraylsMul;
pub type Femtorayls<T> = Quantity<T, UnitFemtorayls>;
#[allow(non_upper_case_globals)]
pub static Femtorayls: UnitFemtoraylsMul = UnitFemtoraylsMul;
pub type Attorayls<T> = Quantity<T, UnitAttorayls>;
#[allow(non_upper_case_globals)]
pub static Attorayls: UnitAttoraylsMul = UnitAttoraylsMul;
pub type Zeptorayls<T> = Quantity<T, UnitZeptorayls>;
#[allow(non_upper_case_globals)]
pub static Zeptorayls: UnitZeptoraylsMul = UnitZeptoraylsMul;
pub type Yoctorayls<T> = Quantity<T, UnitYoctorayls>;
#[allow(non_upper_case_globals)]
pub static Yoctorayls: UnitYoctoraylsMul = UnitYoctoraylsMul;
pub type Rontorayls<T> = Quantity<T, UnitRontorayls>;
#[allow(non_upper_case_globals)]
pub static Rontorayls: UnitRontoraylsMul = UnitRontoraylsMul;
pub type Quectorayls<T> = Quantity<T, UnitQuectorayls>;
#[allow(non_upper_case_globals)]
pub static Quectorayls: UnitQuectoraylsMul = UnitQuectoraylsMul;
pub struct UnitGramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGramForce {
    #[inline]
    fn clone(&self) -> UnitGramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGramForce {
    #[inline]
    fn eq(&self, other: &UnitGramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGramForce {
    fn default() -> Self {
        UnitGramForce
    }
}
impl Add<UnitGramForce> for UnitGramForce {
    type Output = UnitGramForce;
    #[inline]
    fn add(self, _: UnitGramForce) -> Self::Output {
        UnitGramForce
    }
}
impl AddAssign<UnitGramForce> for UnitGramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitGramForce) {}
}
impl Sub<UnitGramForce> for UnitGramForce {
    type Output = UnitGramForce;
    #[inline]
    fn sub(self, _: UnitGramForce) -> Self::Output {
        UnitGramForce
    }
}
impl SubAssign<UnitGramForce> for UnitGramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitGramForce) {}
}
pub struct UnitGramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGramForceMul {
    #[inline]
    fn clone(&self) -> UnitGramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGramForceMul {
    #[inline]
    fn eq(&self, other: &UnitGramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGramForceMul> for i8 {
    type Output = Quantity<i8, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for i16 {
    type Output = Quantity<i16, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for i32 {
    type Output = Quantity<i32, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for i64 {
    type Output = Quantity<i64, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for i128 {
    type Output = Quantity<i128, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for isize {
    type Output = Quantity<isize, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for u8 {
    type Output = Quantity<u8, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for u16 {
    type Output = Quantity<u16, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for u32 {
    type Output = Quantity<u32, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for u64 {
    type Output = Quantity<u64, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for u128 {
    type Output = Quantity<u128, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for usize {
    type Output = Quantity<usize, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for f32 {
    type Output = Quantity<f32, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
impl Mul<UnitGramForceMul> for f64 {
    type Output = Quantity<f64, UnitGramForce>;
    fn mul(self, _: UnitGramForceMul) -> Self::Output {
        Quantity::new(self, UnitGramForce)
    }
}
pub struct UnitQuettagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagramForce {
    #[inline]
    fn clone(&self) -> UnitQuettagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagramForce {
    #[inline]
    fn eq(&self, other: &UnitQuettagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettagramForce {
    fn default() -> Self {
        UnitQuettagramForce
    }
}
impl Add<UnitQuettagramForce> for UnitQuettagramForce {
    type Output = UnitQuettagramForce;
    #[inline]
    fn add(self, _: UnitQuettagramForce) -> Self::Output {
        UnitQuettagramForce
    }
}
impl AddAssign<UnitQuettagramForce> for UnitQuettagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettagramForce) {}
}
impl Sub<UnitQuettagramForce> for UnitQuettagramForce {
    type Output = UnitQuettagramForce;
    #[inline]
    fn sub(self, _: UnitQuettagramForce) -> Self::Output {
        UnitQuettagramForce
    }
}
impl SubAssign<UnitQuettagramForce> for UnitQuettagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettagramForce) {}
}
pub struct UnitQuettagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettagramForceMul {
    #[inline]
    fn clone(&self) -> UnitQuettagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitQuettagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettagramForceMul> for i8 {
    type Output = Quantity<i8, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for i16 {
    type Output = Quantity<i16, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for i32 {
    type Output = Quantity<i32, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for i64 {
    type Output = Quantity<i64, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for i128 {
    type Output = Quantity<i128, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for isize {
    type Output = Quantity<isize, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for u8 {
    type Output = Quantity<u8, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for u16 {
    type Output = Quantity<u16, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for u32 {
    type Output = Quantity<u32, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for u64 {
    type Output = Quantity<u64, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for u128 {
    type Output = Quantity<u128, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for usize {
    type Output = Quantity<usize, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for f32 {
    type Output = Quantity<f32, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
impl Mul<UnitQuettagramForceMul> for f64 {
    type Output = Quantity<f64, UnitQuettagramForce>;
    fn mul(self, _: UnitQuettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuettagramForce)
    }
}
pub struct UnitRonnagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagramForce {
    #[inline]
    fn clone(&self) -> UnitRonnagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagramForce {
    #[inline]
    fn eq(&self, other: &UnitRonnagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnagramForce {
    fn default() -> Self {
        UnitRonnagramForce
    }
}
impl Add<UnitRonnagramForce> for UnitRonnagramForce {
    type Output = UnitRonnagramForce;
    #[inline]
    fn add(self, _: UnitRonnagramForce) -> Self::Output {
        UnitRonnagramForce
    }
}
impl AddAssign<UnitRonnagramForce> for UnitRonnagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnagramForce) {}
}
impl Sub<UnitRonnagramForce> for UnitRonnagramForce {
    type Output = UnitRonnagramForce;
    #[inline]
    fn sub(self, _: UnitRonnagramForce) -> Self::Output {
        UnitRonnagramForce
    }
}
impl SubAssign<UnitRonnagramForce> for UnitRonnagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnagramForce) {}
}
pub struct UnitRonnagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnagramForceMul {
    #[inline]
    fn clone(&self) -> UnitRonnagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitRonnagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnagramForceMul> for i8 {
    type Output = Quantity<i8, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for i16 {
    type Output = Quantity<i16, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for i32 {
    type Output = Quantity<i32, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for i64 {
    type Output = Quantity<i64, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for i128 {
    type Output = Quantity<i128, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for isize {
    type Output = Quantity<isize, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for u8 {
    type Output = Quantity<u8, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for u16 {
    type Output = Quantity<u16, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for u32 {
    type Output = Quantity<u32, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for u64 {
    type Output = Quantity<u64, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for u128 {
    type Output = Quantity<u128, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for usize {
    type Output = Quantity<usize, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for f32 {
    type Output = Quantity<f32, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
impl Mul<UnitRonnagramForceMul> for f64 {
    type Output = Quantity<f64, UnitRonnagramForce>;
    fn mul(self, _: UnitRonnagramForceMul) -> Self::Output {
        Quantity::new(self, UnitRonnagramForce)
    }
}
pub struct UnitYottagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagramForce {
    #[inline]
    fn clone(&self) -> UnitYottagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagramForce {
    #[inline]
    fn eq(&self, other: &UnitYottagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottagramForce {
    fn default() -> Self {
        UnitYottagramForce
    }
}
impl Add<UnitYottagramForce> for UnitYottagramForce {
    type Output = UnitYottagramForce;
    #[inline]
    fn add(self, _: UnitYottagramForce) -> Self::Output {
        UnitYottagramForce
    }
}
impl AddAssign<UnitYottagramForce> for UnitYottagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitYottagramForce) {}
}
impl Sub<UnitYottagramForce> for UnitYottagramForce {
    type Output = UnitYottagramForce;
    #[inline]
    fn sub(self, _: UnitYottagramForce) -> Self::Output {
        UnitYottagramForce
    }
}
impl SubAssign<UnitYottagramForce> for UnitYottagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottagramForce) {}
}
pub struct UnitYottagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottagramForceMul {
    #[inline]
    fn clone(&self) -> UnitYottagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitYottagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottagramForceMul> for i8 {
    type Output = Quantity<i8, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for i16 {
    type Output = Quantity<i16, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for i32 {
    type Output = Quantity<i32, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for i64 {
    type Output = Quantity<i64, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for i128 {
    type Output = Quantity<i128, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for isize {
    type Output = Quantity<isize, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for u8 {
    type Output = Quantity<u8, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for u16 {
    type Output = Quantity<u16, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for u32 {
    type Output = Quantity<u32, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for u64 {
    type Output = Quantity<u64, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for u128 {
    type Output = Quantity<u128, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for usize {
    type Output = Quantity<usize, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for f32 {
    type Output = Quantity<f32, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
impl Mul<UnitYottagramForceMul> for f64 {
    type Output = Quantity<f64, UnitYottagramForce>;
    fn mul(self, _: UnitYottagramForceMul) -> Self::Output {
        Quantity::new(self, UnitYottagramForce)
    }
}
pub struct UnitZettagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagramForce {
    #[inline]
    fn clone(&self) -> UnitZettagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagramForce {
    #[inline]
    fn eq(&self, other: &UnitZettagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettagramForce {
    fn default() -> Self {
        UnitZettagramForce
    }
}
impl Add<UnitZettagramForce> for UnitZettagramForce {
    type Output = UnitZettagramForce;
    #[inline]
    fn add(self, _: UnitZettagramForce) -> Self::Output {
        UnitZettagramForce
    }
}
impl AddAssign<UnitZettagramForce> for UnitZettagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitZettagramForce) {}
}
impl Sub<UnitZettagramForce> for UnitZettagramForce {
    type Output = UnitZettagramForce;
    #[inline]
    fn sub(self, _: UnitZettagramForce) -> Self::Output {
        UnitZettagramForce
    }
}
impl SubAssign<UnitZettagramForce> for UnitZettagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettagramForce) {}
}
pub struct UnitZettagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettagramForceMul {
    #[inline]
    fn clone(&self) -> UnitZettagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitZettagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettagramForceMul> for i8 {
    type Output = Quantity<i8, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for i16 {
    type Output = Quantity<i16, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for i32 {
    type Output = Quantity<i32, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for i64 {
    type Output = Quantity<i64, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for i128 {
    type Output = Quantity<i128, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for isize {
    type Output = Quantity<isize, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for u8 {
    type Output = Quantity<u8, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for u16 {
    type Output = Quantity<u16, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for u32 {
    type Output = Quantity<u32, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for u64 {
    type Output = Quantity<u64, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for u128 {
    type Output = Quantity<u128, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for usize {
    type Output = Quantity<usize, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for f32 {
    type Output = Quantity<f32, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
impl Mul<UnitZettagramForceMul> for f64 {
    type Output = Quantity<f64, UnitZettagramForce>;
    fn mul(self, _: UnitZettagramForceMul) -> Self::Output {
        Quantity::new(self, UnitZettagramForce)
    }
}
pub struct UnitExagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagramForce {
    #[inline]
    fn clone(&self) -> UnitExagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagramForce {
    #[inline]
    fn eq(&self, other: &UnitExagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExagramForce {
    fn default() -> Self {
        UnitExagramForce
    }
}
impl Add<UnitExagramForce> for UnitExagramForce {
    type Output = UnitExagramForce;
    #[inline]
    fn add(self, _: UnitExagramForce) -> Self::Output {
        UnitExagramForce
    }
}
impl AddAssign<UnitExagramForce> for UnitExagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitExagramForce) {}
}
impl Sub<UnitExagramForce> for UnitExagramForce {
    type Output = UnitExagramForce;
    #[inline]
    fn sub(self, _: UnitExagramForce) -> Self::Output {
        UnitExagramForce
    }
}
impl SubAssign<UnitExagramForce> for UnitExagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitExagramForce) {}
}
pub struct UnitExagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExagramForceMul {
    #[inline]
    fn clone(&self) -> UnitExagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitExagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExagramForceMul> for i8 {
    type Output = Quantity<i8, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for i16 {
    type Output = Quantity<i16, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for i32 {
    type Output = Quantity<i32, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for i64 {
    type Output = Quantity<i64, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for i128 {
    type Output = Quantity<i128, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for isize {
    type Output = Quantity<isize, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for u8 {
    type Output = Quantity<u8, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for u16 {
    type Output = Quantity<u16, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for u32 {
    type Output = Quantity<u32, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for u64 {
    type Output = Quantity<u64, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for u128 {
    type Output = Quantity<u128, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for usize {
    type Output = Quantity<usize, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for f32 {
    type Output = Quantity<f32, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
impl Mul<UnitExagramForceMul> for f64 {
    type Output = Quantity<f64, UnitExagramForce>;
    fn mul(self, _: UnitExagramForceMul) -> Self::Output {
        Quantity::new(self, UnitExagramForce)
    }
}
pub struct UnitPetagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagramForce {
    #[inline]
    fn clone(&self) -> UnitPetagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagramForce {
    #[inline]
    fn eq(&self, other: &UnitPetagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetagramForce {
    fn default() -> Self {
        UnitPetagramForce
    }
}
impl Add<UnitPetagramForce> for UnitPetagramForce {
    type Output = UnitPetagramForce;
    #[inline]
    fn add(self, _: UnitPetagramForce) -> Self::Output {
        UnitPetagramForce
    }
}
impl AddAssign<UnitPetagramForce> for UnitPetagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitPetagramForce) {}
}
impl Sub<UnitPetagramForce> for UnitPetagramForce {
    type Output = UnitPetagramForce;
    #[inline]
    fn sub(self, _: UnitPetagramForce) -> Self::Output {
        UnitPetagramForce
    }
}
impl SubAssign<UnitPetagramForce> for UnitPetagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetagramForce) {}
}
pub struct UnitPetagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetagramForceMul {
    #[inline]
    fn clone(&self) -> UnitPetagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitPetagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetagramForceMul> for i8 {
    type Output = Quantity<i8, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for i16 {
    type Output = Quantity<i16, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for i32 {
    type Output = Quantity<i32, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for i64 {
    type Output = Quantity<i64, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for i128 {
    type Output = Quantity<i128, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for isize {
    type Output = Quantity<isize, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for u8 {
    type Output = Quantity<u8, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for u16 {
    type Output = Quantity<u16, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for u32 {
    type Output = Quantity<u32, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for u64 {
    type Output = Quantity<u64, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for u128 {
    type Output = Quantity<u128, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for usize {
    type Output = Quantity<usize, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for f32 {
    type Output = Quantity<f32, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
impl Mul<UnitPetagramForceMul> for f64 {
    type Output = Quantity<f64, UnitPetagramForce>;
    fn mul(self, _: UnitPetagramForceMul) -> Self::Output {
        Quantity::new(self, UnitPetagramForce)
    }
}
pub struct UnitTeragramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragramForce {
    #[inline]
    fn clone(&self) -> UnitTeragramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragramForce {
    #[inline]
    fn eq(&self, other: &UnitTeragramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeragramForce {
    fn default() -> Self {
        UnitTeragramForce
    }
}
impl Add<UnitTeragramForce> for UnitTeragramForce {
    type Output = UnitTeragramForce;
    #[inline]
    fn add(self, _: UnitTeragramForce) -> Self::Output {
        UnitTeragramForce
    }
}
impl AddAssign<UnitTeragramForce> for UnitTeragramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitTeragramForce) {}
}
impl Sub<UnitTeragramForce> for UnitTeragramForce {
    type Output = UnitTeragramForce;
    #[inline]
    fn sub(self, _: UnitTeragramForce) -> Self::Output {
        UnitTeragramForce
    }
}
impl SubAssign<UnitTeragramForce> for UnitTeragramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeragramForce) {}
}
pub struct UnitTeragramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeragramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeragramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeragramForceMul {
    #[inline]
    fn clone(&self) -> UnitTeragramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeragramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeragramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeragramForceMul {
    #[inline]
    fn eq(&self, other: &UnitTeragramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeragramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeragramForceMul> for i8 {
    type Output = Quantity<i8, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for i16 {
    type Output = Quantity<i16, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for i32 {
    type Output = Quantity<i32, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for i64 {
    type Output = Quantity<i64, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for i128 {
    type Output = Quantity<i128, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for isize {
    type Output = Quantity<isize, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for u8 {
    type Output = Quantity<u8, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for u16 {
    type Output = Quantity<u16, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for u32 {
    type Output = Quantity<u32, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for u64 {
    type Output = Quantity<u64, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for u128 {
    type Output = Quantity<u128, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for usize {
    type Output = Quantity<usize, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for f32 {
    type Output = Quantity<f32, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
impl Mul<UnitTeragramForceMul> for f64 {
    type Output = Quantity<f64, UnitTeragramForce>;
    fn mul(self, _: UnitTeragramForceMul) -> Self::Output {
        Quantity::new(self, UnitTeragramForce)
    }
}
pub struct UnitGigagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagramForce {
    #[inline]
    fn clone(&self) -> UnitGigagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagramForce {
    #[inline]
    fn eq(&self, other: &UnitGigagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigagramForce {
    fn default() -> Self {
        UnitGigagramForce
    }
}
impl Add<UnitGigagramForce> for UnitGigagramForce {
    type Output = UnitGigagramForce;
    #[inline]
    fn add(self, _: UnitGigagramForce) -> Self::Output {
        UnitGigagramForce
    }
}
impl AddAssign<UnitGigagramForce> for UnitGigagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitGigagramForce) {}
}
impl Sub<UnitGigagramForce> for UnitGigagramForce {
    type Output = UnitGigagramForce;
    #[inline]
    fn sub(self, _: UnitGigagramForce) -> Self::Output {
        UnitGigagramForce
    }
}
impl SubAssign<UnitGigagramForce> for UnitGigagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigagramForce) {}
}
pub struct UnitGigagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigagramForceMul {
    #[inline]
    fn clone(&self) -> UnitGigagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitGigagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigagramForceMul> for i8 {
    type Output = Quantity<i8, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for i16 {
    type Output = Quantity<i16, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for i32 {
    type Output = Quantity<i32, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for i64 {
    type Output = Quantity<i64, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for i128 {
    type Output = Quantity<i128, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for isize {
    type Output = Quantity<isize, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for u8 {
    type Output = Quantity<u8, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for u16 {
    type Output = Quantity<u16, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for u32 {
    type Output = Quantity<u32, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for u64 {
    type Output = Quantity<u64, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for u128 {
    type Output = Quantity<u128, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for usize {
    type Output = Quantity<usize, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for f32 {
    type Output = Quantity<f32, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
impl Mul<UnitGigagramForceMul> for f64 {
    type Output = Quantity<f64, UnitGigagramForce>;
    fn mul(self, _: UnitGigagramForceMul) -> Self::Output {
        Quantity::new(self, UnitGigagramForce)
    }
}
pub struct UnitMegagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagramForce {
    #[inline]
    fn clone(&self) -> UnitMegagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagramForce {
    #[inline]
    fn eq(&self, other: &UnitMegagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegagramForce {
    fn default() -> Self {
        UnitMegagramForce
    }
}
impl Add<UnitMegagramForce> for UnitMegagramForce {
    type Output = UnitMegagramForce;
    #[inline]
    fn add(self, _: UnitMegagramForce) -> Self::Output {
        UnitMegagramForce
    }
}
impl AddAssign<UnitMegagramForce> for UnitMegagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitMegagramForce) {}
}
impl Sub<UnitMegagramForce> for UnitMegagramForce {
    type Output = UnitMegagramForce;
    #[inline]
    fn sub(self, _: UnitMegagramForce) -> Self::Output {
        UnitMegagramForce
    }
}
impl SubAssign<UnitMegagramForce> for UnitMegagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegagramForce) {}
}
pub struct UnitMegagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegagramForceMul {
    #[inline]
    fn clone(&self) -> UnitMegagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitMegagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegagramForceMul> for i8 {
    type Output = Quantity<i8, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for i16 {
    type Output = Quantity<i16, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for i32 {
    type Output = Quantity<i32, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for i64 {
    type Output = Quantity<i64, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for i128 {
    type Output = Quantity<i128, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for isize {
    type Output = Quantity<isize, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for u8 {
    type Output = Quantity<u8, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for u16 {
    type Output = Quantity<u16, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for u32 {
    type Output = Quantity<u32, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for u64 {
    type Output = Quantity<u64, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for u128 {
    type Output = Quantity<u128, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for usize {
    type Output = Quantity<usize, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for f32 {
    type Output = Quantity<f32, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
impl Mul<UnitMegagramForceMul> for f64 {
    type Output = Quantity<f64, UnitMegagramForce>;
    fn mul(self, _: UnitMegagramForceMul) -> Self::Output {
        Quantity::new(self, UnitMegagramForce)
    }
}
pub struct UnitKilogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilogramForce {
    #[inline]
    fn clone(&self) -> UnitKilogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilogramForce {
    #[inline]
    fn eq(&self, other: &UnitKilogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilogramForce {
    fn default() -> Self {
        UnitKilogramForce
    }
}
impl Add<UnitKilogramForce> for UnitKilogramForce {
    type Output = UnitKilogramForce;
    #[inline]
    fn add(self, _: UnitKilogramForce) -> Self::Output {
        UnitKilogramForce
    }
}
impl AddAssign<UnitKilogramForce> for UnitKilogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitKilogramForce) {}
}
impl Sub<UnitKilogramForce> for UnitKilogramForce {
    type Output = UnitKilogramForce;
    #[inline]
    fn sub(self, _: UnitKilogramForce) -> Self::Output {
        UnitKilogramForce
    }
}
impl SubAssign<UnitKilogramForce> for UnitKilogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilogramForce) {}
}
pub struct UnitKilogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilogramForceMul {
    #[inline]
    fn clone(&self) -> UnitKilogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitKilogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilogramForceMul> for i8 {
    type Output = Quantity<i8, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for i16 {
    type Output = Quantity<i16, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for i32 {
    type Output = Quantity<i32, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for i64 {
    type Output = Quantity<i64, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for i128 {
    type Output = Quantity<i128, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for isize {
    type Output = Quantity<isize, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for u8 {
    type Output = Quantity<u8, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for u16 {
    type Output = Quantity<u16, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for u32 {
    type Output = Quantity<u32, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for u64 {
    type Output = Quantity<u64, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for u128 {
    type Output = Quantity<u128, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for usize {
    type Output = Quantity<usize, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for f32 {
    type Output = Quantity<f32, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
impl Mul<UnitKilogramForceMul> for f64 {
    type Output = Quantity<f64, UnitKilogramForce>;
    fn mul(self, _: UnitKilogramForceMul) -> Self::Output {
        Quantity::new(self, UnitKilogramForce)
    }
}
pub struct UnitHectogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectogramForce {
    #[inline]
    fn clone(&self) -> UnitHectogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectogramForce {
    #[inline]
    fn eq(&self, other: &UnitHectogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectogramForce {
    fn default() -> Self {
        UnitHectogramForce
    }
}
impl Add<UnitHectogramForce> for UnitHectogramForce {
    type Output = UnitHectogramForce;
    #[inline]
    fn add(self, _: UnitHectogramForce) -> Self::Output {
        UnitHectogramForce
    }
}
impl AddAssign<UnitHectogramForce> for UnitHectogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitHectogramForce) {}
}
impl Sub<UnitHectogramForce> for UnitHectogramForce {
    type Output = UnitHectogramForce;
    #[inline]
    fn sub(self, _: UnitHectogramForce) -> Self::Output {
        UnitHectogramForce
    }
}
impl SubAssign<UnitHectogramForce> for UnitHectogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectogramForce) {}
}
pub struct UnitHectogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectogramForceMul {
    #[inline]
    fn clone(&self) -> UnitHectogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitHectogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectogramForceMul> for i8 {
    type Output = Quantity<i8, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for i16 {
    type Output = Quantity<i16, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for i32 {
    type Output = Quantity<i32, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for i64 {
    type Output = Quantity<i64, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for i128 {
    type Output = Quantity<i128, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for isize {
    type Output = Quantity<isize, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for u8 {
    type Output = Quantity<u8, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for u16 {
    type Output = Quantity<u16, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for u32 {
    type Output = Quantity<u32, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for u64 {
    type Output = Quantity<u64, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for u128 {
    type Output = Quantity<u128, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for usize {
    type Output = Quantity<usize, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for f32 {
    type Output = Quantity<f32, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
impl Mul<UnitHectogramForceMul> for f64 {
    type Output = Quantity<f64, UnitHectogramForce>;
    fn mul(self, _: UnitHectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitHectogramForce)
    }
}
pub struct UnitDecagramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagramForce {
    #[inline]
    fn clone(&self) -> UnitDecagramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagramForce {
    #[inline]
    fn eq(&self, other: &UnitDecagramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecagramForce {
    fn default() -> Self {
        UnitDecagramForce
    }
}
impl Add<UnitDecagramForce> for UnitDecagramForce {
    type Output = UnitDecagramForce;
    #[inline]
    fn add(self, _: UnitDecagramForce) -> Self::Output {
        UnitDecagramForce
    }
}
impl AddAssign<UnitDecagramForce> for UnitDecagramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitDecagramForce) {}
}
impl Sub<UnitDecagramForce> for UnitDecagramForce {
    type Output = UnitDecagramForce;
    #[inline]
    fn sub(self, _: UnitDecagramForce) -> Self::Output {
        UnitDecagramForce
    }
}
impl SubAssign<UnitDecagramForce> for UnitDecagramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecagramForce) {}
}
pub struct UnitDecagramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecagramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecagramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecagramForceMul {
    #[inline]
    fn clone(&self) -> UnitDecagramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecagramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecagramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecagramForceMul {
    #[inline]
    fn eq(&self, other: &UnitDecagramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecagramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecagramForceMul> for i8 {
    type Output = Quantity<i8, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for i16 {
    type Output = Quantity<i16, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for i32 {
    type Output = Quantity<i32, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for i64 {
    type Output = Quantity<i64, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for i128 {
    type Output = Quantity<i128, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for isize {
    type Output = Quantity<isize, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for u8 {
    type Output = Quantity<u8, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for u16 {
    type Output = Quantity<u16, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for u32 {
    type Output = Quantity<u32, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for u64 {
    type Output = Quantity<u64, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for u128 {
    type Output = Quantity<u128, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for usize {
    type Output = Quantity<usize, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for f32 {
    type Output = Quantity<f32, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
impl Mul<UnitDecagramForceMul> for f64 {
    type Output = Quantity<f64, UnitDecagramForce>;
    fn mul(self, _: UnitDecagramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecagramForce)
    }
}
pub struct UnitDecigramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigramForce {
    #[inline]
    fn clone(&self) -> UnitDecigramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigramForce {
    #[inline]
    fn eq(&self, other: &UnitDecigramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecigramForce {
    fn default() -> Self {
        UnitDecigramForce
    }
}
impl Add<UnitDecigramForce> for UnitDecigramForce {
    type Output = UnitDecigramForce;
    #[inline]
    fn add(self, _: UnitDecigramForce) -> Self::Output {
        UnitDecigramForce
    }
}
impl AddAssign<UnitDecigramForce> for UnitDecigramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitDecigramForce) {}
}
impl Sub<UnitDecigramForce> for UnitDecigramForce {
    type Output = UnitDecigramForce;
    #[inline]
    fn sub(self, _: UnitDecigramForce) -> Self::Output {
        UnitDecigramForce
    }
}
impl SubAssign<UnitDecigramForce> for UnitDecigramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecigramForce) {}
}
pub struct UnitDecigramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecigramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecigramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecigramForceMul {
    #[inline]
    fn clone(&self) -> UnitDecigramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecigramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecigramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecigramForceMul {
    #[inline]
    fn eq(&self, other: &UnitDecigramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecigramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecigramForceMul> for i8 {
    type Output = Quantity<i8, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for i16 {
    type Output = Quantity<i16, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for i32 {
    type Output = Quantity<i32, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for i64 {
    type Output = Quantity<i64, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for i128 {
    type Output = Quantity<i128, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for isize {
    type Output = Quantity<isize, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for u8 {
    type Output = Quantity<u8, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for u16 {
    type Output = Quantity<u16, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for u32 {
    type Output = Quantity<u32, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for u64 {
    type Output = Quantity<u64, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for u128 {
    type Output = Quantity<u128, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for usize {
    type Output = Quantity<usize, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for f32 {
    type Output = Quantity<f32, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
impl Mul<UnitDecigramForceMul> for f64 {
    type Output = Quantity<f64, UnitDecigramForce>;
    fn mul(self, _: UnitDecigramForceMul) -> Self::Output {
        Quantity::new(self, UnitDecigramForce)
    }
}
pub struct UnitCentigramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigramForce {
    #[inline]
    fn clone(&self) -> UnitCentigramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigramForce {
    #[inline]
    fn eq(&self, other: &UnitCentigramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentigramForce {
    fn default() -> Self {
        UnitCentigramForce
    }
}
impl Add<UnitCentigramForce> for UnitCentigramForce {
    type Output = UnitCentigramForce;
    #[inline]
    fn add(self, _: UnitCentigramForce) -> Self::Output {
        UnitCentigramForce
    }
}
impl AddAssign<UnitCentigramForce> for UnitCentigramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitCentigramForce) {}
}
impl Sub<UnitCentigramForce> for UnitCentigramForce {
    type Output = UnitCentigramForce;
    #[inline]
    fn sub(self, _: UnitCentigramForce) -> Self::Output {
        UnitCentigramForce
    }
}
impl SubAssign<UnitCentigramForce> for UnitCentigramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentigramForce) {}
}
pub struct UnitCentigramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentigramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentigramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentigramForceMul {
    #[inline]
    fn clone(&self) -> UnitCentigramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentigramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentigramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentigramForceMul {
    #[inline]
    fn eq(&self, other: &UnitCentigramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentigramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentigramForceMul> for i8 {
    type Output = Quantity<i8, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for i16 {
    type Output = Quantity<i16, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for i32 {
    type Output = Quantity<i32, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for i64 {
    type Output = Quantity<i64, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for i128 {
    type Output = Quantity<i128, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for isize {
    type Output = Quantity<isize, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for u8 {
    type Output = Quantity<u8, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for u16 {
    type Output = Quantity<u16, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for u32 {
    type Output = Quantity<u32, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for u64 {
    type Output = Quantity<u64, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for u128 {
    type Output = Quantity<u128, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for usize {
    type Output = Quantity<usize, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for f32 {
    type Output = Quantity<f32, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
impl Mul<UnitCentigramForceMul> for f64 {
    type Output = Quantity<f64, UnitCentigramForce>;
    fn mul(self, _: UnitCentigramForceMul) -> Self::Output {
        Quantity::new(self, UnitCentigramForce)
    }
}
pub struct UnitMilligramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligramForce {
    #[inline]
    fn clone(&self) -> UnitMilligramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligramForce {
    #[inline]
    fn eq(&self, other: &UnitMilligramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilligramForce {
    fn default() -> Self {
        UnitMilligramForce
    }
}
impl Add<UnitMilligramForce> for UnitMilligramForce {
    type Output = UnitMilligramForce;
    #[inline]
    fn add(self, _: UnitMilligramForce) -> Self::Output {
        UnitMilligramForce
    }
}
impl AddAssign<UnitMilligramForce> for UnitMilligramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitMilligramForce) {}
}
impl Sub<UnitMilligramForce> for UnitMilligramForce {
    type Output = UnitMilligramForce;
    #[inline]
    fn sub(self, _: UnitMilligramForce) -> Self::Output {
        UnitMilligramForce
    }
}
impl SubAssign<UnitMilligramForce> for UnitMilligramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilligramForce) {}
}
pub struct UnitMilligramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilligramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilligramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilligramForceMul {
    #[inline]
    fn clone(&self) -> UnitMilligramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilligramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilligramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilligramForceMul {
    #[inline]
    fn eq(&self, other: &UnitMilligramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilligramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilligramForceMul> for i8 {
    type Output = Quantity<i8, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for i16 {
    type Output = Quantity<i16, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for i32 {
    type Output = Quantity<i32, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for i64 {
    type Output = Quantity<i64, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for i128 {
    type Output = Quantity<i128, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for isize {
    type Output = Quantity<isize, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for u8 {
    type Output = Quantity<u8, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for u16 {
    type Output = Quantity<u16, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for u32 {
    type Output = Quantity<u32, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for u64 {
    type Output = Quantity<u64, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for u128 {
    type Output = Quantity<u128, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for usize {
    type Output = Quantity<usize, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for f32 {
    type Output = Quantity<f32, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
impl Mul<UnitMilligramForceMul> for f64 {
    type Output = Quantity<f64, UnitMilligramForce>;
    fn mul(self, _: UnitMilligramForceMul) -> Self::Output {
        Quantity::new(self, UnitMilligramForce)
    }
}
pub struct UnitMicrogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrogramForce {
    #[inline]
    fn clone(&self) -> UnitMicrogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrogramForce {
    #[inline]
    fn eq(&self, other: &UnitMicrogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrogramForce {
    fn default() -> Self {
        UnitMicrogramForce
    }
}
impl Add<UnitMicrogramForce> for UnitMicrogramForce {
    type Output = UnitMicrogramForce;
    #[inline]
    fn add(self, _: UnitMicrogramForce) -> Self::Output {
        UnitMicrogramForce
    }
}
impl AddAssign<UnitMicrogramForce> for UnitMicrogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrogramForce) {}
}
impl Sub<UnitMicrogramForce> for UnitMicrogramForce {
    type Output = UnitMicrogramForce;
    #[inline]
    fn sub(self, _: UnitMicrogramForce) -> Self::Output {
        UnitMicrogramForce
    }
}
impl SubAssign<UnitMicrogramForce> for UnitMicrogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrogramForce) {}
}
pub struct UnitMicrogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrogramForceMul {
    #[inline]
    fn clone(&self) -> UnitMicrogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitMicrogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrogramForceMul> for i8 {
    type Output = Quantity<i8, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for i16 {
    type Output = Quantity<i16, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for i32 {
    type Output = Quantity<i32, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for i64 {
    type Output = Quantity<i64, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for i128 {
    type Output = Quantity<i128, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for isize {
    type Output = Quantity<isize, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for u8 {
    type Output = Quantity<u8, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for u16 {
    type Output = Quantity<u16, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for u32 {
    type Output = Quantity<u32, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for u64 {
    type Output = Quantity<u64, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for u128 {
    type Output = Quantity<u128, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for usize {
    type Output = Quantity<usize, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for f32 {
    type Output = Quantity<f32, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
impl Mul<UnitMicrogramForceMul> for f64 {
    type Output = Quantity<f64, UnitMicrogramForce>;
    fn mul(self, _: UnitMicrogramForceMul) -> Self::Output {
        Quantity::new(self, UnitMicrogramForce)
    }
}
pub struct UnitNanogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanogramForce {
    #[inline]
    fn clone(&self) -> UnitNanogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanogramForce {
    #[inline]
    fn eq(&self, other: &UnitNanogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanogramForce {
    fn default() -> Self {
        UnitNanogramForce
    }
}
impl Add<UnitNanogramForce> for UnitNanogramForce {
    type Output = UnitNanogramForce;
    #[inline]
    fn add(self, _: UnitNanogramForce) -> Self::Output {
        UnitNanogramForce
    }
}
impl AddAssign<UnitNanogramForce> for UnitNanogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitNanogramForce) {}
}
impl Sub<UnitNanogramForce> for UnitNanogramForce {
    type Output = UnitNanogramForce;
    #[inline]
    fn sub(self, _: UnitNanogramForce) -> Self::Output {
        UnitNanogramForce
    }
}
impl SubAssign<UnitNanogramForce> for UnitNanogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanogramForce) {}
}
pub struct UnitNanogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanogramForceMul {
    #[inline]
    fn clone(&self) -> UnitNanogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitNanogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanogramForceMul> for i8 {
    type Output = Quantity<i8, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for i16 {
    type Output = Quantity<i16, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for i32 {
    type Output = Quantity<i32, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for i64 {
    type Output = Quantity<i64, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for i128 {
    type Output = Quantity<i128, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for isize {
    type Output = Quantity<isize, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for u8 {
    type Output = Quantity<u8, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for u16 {
    type Output = Quantity<u16, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for u32 {
    type Output = Quantity<u32, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for u64 {
    type Output = Quantity<u64, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for u128 {
    type Output = Quantity<u128, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for usize {
    type Output = Quantity<usize, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for f32 {
    type Output = Quantity<f32, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
impl Mul<UnitNanogramForceMul> for f64 {
    type Output = Quantity<f64, UnitNanogramForce>;
    fn mul(self, _: UnitNanogramForceMul) -> Self::Output {
        Quantity::new(self, UnitNanogramForce)
    }
}
pub struct UnitPicogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicogramForce {
    #[inline]
    fn clone(&self) -> UnitPicogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicogramForce {
    #[inline]
    fn eq(&self, other: &UnitPicogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicogramForce {
    fn default() -> Self {
        UnitPicogramForce
    }
}
impl Add<UnitPicogramForce> for UnitPicogramForce {
    type Output = UnitPicogramForce;
    #[inline]
    fn add(self, _: UnitPicogramForce) -> Self::Output {
        UnitPicogramForce
    }
}
impl AddAssign<UnitPicogramForce> for UnitPicogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitPicogramForce) {}
}
impl Sub<UnitPicogramForce> for UnitPicogramForce {
    type Output = UnitPicogramForce;
    #[inline]
    fn sub(self, _: UnitPicogramForce) -> Self::Output {
        UnitPicogramForce
    }
}
impl SubAssign<UnitPicogramForce> for UnitPicogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicogramForce) {}
}
pub struct UnitPicogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicogramForceMul {
    #[inline]
    fn clone(&self) -> UnitPicogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitPicogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicogramForceMul> for i8 {
    type Output = Quantity<i8, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for i16 {
    type Output = Quantity<i16, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for i32 {
    type Output = Quantity<i32, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for i64 {
    type Output = Quantity<i64, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for i128 {
    type Output = Quantity<i128, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for isize {
    type Output = Quantity<isize, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for u8 {
    type Output = Quantity<u8, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for u16 {
    type Output = Quantity<u16, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for u32 {
    type Output = Quantity<u32, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for u64 {
    type Output = Quantity<u64, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for u128 {
    type Output = Quantity<u128, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for usize {
    type Output = Quantity<usize, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for f32 {
    type Output = Quantity<f32, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
impl Mul<UnitPicogramForceMul> for f64 {
    type Output = Quantity<f64, UnitPicogramForce>;
    fn mul(self, _: UnitPicogramForceMul) -> Self::Output {
        Quantity::new(self, UnitPicogramForce)
    }
}
pub struct UnitFemtogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtogramForce {
    #[inline]
    fn clone(&self) -> UnitFemtogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtogramForce {
    #[inline]
    fn eq(&self, other: &UnitFemtogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtogramForce {
    fn default() -> Self {
        UnitFemtogramForce
    }
}
impl Add<UnitFemtogramForce> for UnitFemtogramForce {
    type Output = UnitFemtogramForce;
    #[inline]
    fn add(self, _: UnitFemtogramForce) -> Self::Output {
        UnitFemtogramForce
    }
}
impl AddAssign<UnitFemtogramForce> for UnitFemtogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtogramForce) {}
}
impl Sub<UnitFemtogramForce> for UnitFemtogramForce {
    type Output = UnitFemtogramForce;
    #[inline]
    fn sub(self, _: UnitFemtogramForce) -> Self::Output {
        UnitFemtogramForce
    }
}
impl SubAssign<UnitFemtogramForce> for UnitFemtogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtogramForce) {}
}
pub struct UnitFemtogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtogramForceMul {
    #[inline]
    fn clone(&self) -> UnitFemtogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitFemtogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtogramForceMul> for i8 {
    type Output = Quantity<i8, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for i16 {
    type Output = Quantity<i16, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for i32 {
    type Output = Quantity<i32, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for i64 {
    type Output = Quantity<i64, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for i128 {
    type Output = Quantity<i128, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for isize {
    type Output = Quantity<isize, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for u8 {
    type Output = Quantity<u8, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for u16 {
    type Output = Quantity<u16, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for u32 {
    type Output = Quantity<u32, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for u64 {
    type Output = Quantity<u64, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for u128 {
    type Output = Quantity<u128, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for usize {
    type Output = Quantity<usize, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for f32 {
    type Output = Quantity<f32, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
impl Mul<UnitFemtogramForceMul> for f64 {
    type Output = Quantity<f64, UnitFemtogramForce>;
    fn mul(self, _: UnitFemtogramForceMul) -> Self::Output {
        Quantity::new(self, UnitFemtogramForce)
    }
}
pub struct UnitAttogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttogramForce {
    #[inline]
    fn clone(&self) -> UnitAttogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttogramForce {
    #[inline]
    fn eq(&self, other: &UnitAttogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttogramForce {
    fn default() -> Self {
        UnitAttogramForce
    }
}
impl Add<UnitAttogramForce> for UnitAttogramForce {
    type Output = UnitAttogramForce;
    #[inline]
    fn add(self, _: UnitAttogramForce) -> Self::Output {
        UnitAttogramForce
    }
}
impl AddAssign<UnitAttogramForce> for UnitAttogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitAttogramForce) {}
}
impl Sub<UnitAttogramForce> for UnitAttogramForce {
    type Output = UnitAttogramForce;
    #[inline]
    fn sub(self, _: UnitAttogramForce) -> Self::Output {
        UnitAttogramForce
    }
}
impl SubAssign<UnitAttogramForce> for UnitAttogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttogramForce) {}
}
pub struct UnitAttogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttogramForceMul {
    #[inline]
    fn clone(&self) -> UnitAttogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitAttogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttogramForceMul> for i8 {
    type Output = Quantity<i8, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for i16 {
    type Output = Quantity<i16, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for i32 {
    type Output = Quantity<i32, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for i64 {
    type Output = Quantity<i64, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for i128 {
    type Output = Quantity<i128, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for isize {
    type Output = Quantity<isize, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for u8 {
    type Output = Quantity<u8, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for u16 {
    type Output = Quantity<u16, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for u32 {
    type Output = Quantity<u32, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for u64 {
    type Output = Quantity<u64, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for u128 {
    type Output = Quantity<u128, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for usize {
    type Output = Quantity<usize, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for f32 {
    type Output = Quantity<f32, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
impl Mul<UnitAttogramForceMul> for f64 {
    type Output = Quantity<f64, UnitAttogramForce>;
    fn mul(self, _: UnitAttogramForceMul) -> Self::Output {
        Quantity::new(self, UnitAttogramForce)
    }
}
pub struct UnitZeptogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptogramForce {
    #[inline]
    fn clone(&self) -> UnitZeptogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptogramForce {
    #[inline]
    fn eq(&self, other: &UnitZeptogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptogramForce {
    fn default() -> Self {
        UnitZeptogramForce
    }
}
impl Add<UnitZeptogramForce> for UnitZeptogramForce {
    type Output = UnitZeptogramForce;
    #[inline]
    fn add(self, _: UnitZeptogramForce) -> Self::Output {
        UnitZeptogramForce
    }
}
impl AddAssign<UnitZeptogramForce> for UnitZeptogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptogramForce) {}
}
impl Sub<UnitZeptogramForce> for UnitZeptogramForce {
    type Output = UnitZeptogramForce;
    #[inline]
    fn sub(self, _: UnitZeptogramForce) -> Self::Output {
        UnitZeptogramForce
    }
}
impl SubAssign<UnitZeptogramForce> for UnitZeptogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptogramForce) {}
}
pub struct UnitZeptogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptogramForceMul {
    #[inline]
    fn clone(&self) -> UnitZeptogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitZeptogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptogramForceMul> for i8 {
    type Output = Quantity<i8, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for i16 {
    type Output = Quantity<i16, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for i32 {
    type Output = Quantity<i32, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for i64 {
    type Output = Quantity<i64, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for i128 {
    type Output = Quantity<i128, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for isize {
    type Output = Quantity<isize, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for u8 {
    type Output = Quantity<u8, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for u16 {
    type Output = Quantity<u16, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for u32 {
    type Output = Quantity<u32, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for u64 {
    type Output = Quantity<u64, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for u128 {
    type Output = Quantity<u128, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for usize {
    type Output = Quantity<usize, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for f32 {
    type Output = Quantity<f32, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
impl Mul<UnitZeptogramForceMul> for f64 {
    type Output = Quantity<f64, UnitZeptogramForce>;
    fn mul(self, _: UnitZeptogramForceMul) -> Self::Output {
        Quantity::new(self, UnitZeptogramForce)
    }
}
pub struct UnitYoctogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctogramForce {
    #[inline]
    fn clone(&self) -> UnitYoctogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctogramForce {
    #[inline]
    fn eq(&self, other: &UnitYoctogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctogramForce {
    fn default() -> Self {
        UnitYoctogramForce
    }
}
impl Add<UnitYoctogramForce> for UnitYoctogramForce {
    type Output = UnitYoctogramForce;
    #[inline]
    fn add(self, _: UnitYoctogramForce) -> Self::Output {
        UnitYoctogramForce
    }
}
impl AddAssign<UnitYoctogramForce> for UnitYoctogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctogramForce) {}
}
impl Sub<UnitYoctogramForce> for UnitYoctogramForce {
    type Output = UnitYoctogramForce;
    #[inline]
    fn sub(self, _: UnitYoctogramForce) -> Self::Output {
        UnitYoctogramForce
    }
}
impl SubAssign<UnitYoctogramForce> for UnitYoctogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctogramForce) {}
}
pub struct UnitYoctogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctogramForceMul {
    #[inline]
    fn clone(&self) -> UnitYoctogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitYoctogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctogramForceMul> for i8 {
    type Output = Quantity<i8, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for i16 {
    type Output = Quantity<i16, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for i32 {
    type Output = Quantity<i32, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for i64 {
    type Output = Quantity<i64, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for i128 {
    type Output = Quantity<i128, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for isize {
    type Output = Quantity<isize, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for u8 {
    type Output = Quantity<u8, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for u16 {
    type Output = Quantity<u16, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for u32 {
    type Output = Quantity<u32, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for u64 {
    type Output = Quantity<u64, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for u128 {
    type Output = Quantity<u128, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for usize {
    type Output = Quantity<usize, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for f32 {
    type Output = Quantity<f32, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
impl Mul<UnitYoctogramForceMul> for f64 {
    type Output = Quantity<f64, UnitYoctogramForce>;
    fn mul(self, _: UnitYoctogramForceMul) -> Self::Output {
        Quantity::new(self, UnitYoctogramForce)
    }
}
pub struct UnitRontogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontogramForce {
    #[inline]
    fn clone(&self) -> UnitRontogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontogramForce {
    #[inline]
    fn eq(&self, other: &UnitRontogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontogramForce {
    fn default() -> Self {
        UnitRontogramForce
    }
}
impl Add<UnitRontogramForce> for UnitRontogramForce {
    type Output = UnitRontogramForce;
    #[inline]
    fn add(self, _: UnitRontogramForce) -> Self::Output {
        UnitRontogramForce
    }
}
impl AddAssign<UnitRontogramForce> for UnitRontogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitRontogramForce) {}
}
impl Sub<UnitRontogramForce> for UnitRontogramForce {
    type Output = UnitRontogramForce;
    #[inline]
    fn sub(self, _: UnitRontogramForce) -> Self::Output {
        UnitRontogramForce
    }
}
impl SubAssign<UnitRontogramForce> for UnitRontogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontogramForce) {}
}
pub struct UnitRontogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontogramForceMul {
    #[inline]
    fn clone(&self) -> UnitRontogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitRontogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontogramForceMul> for i8 {
    type Output = Quantity<i8, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for i16 {
    type Output = Quantity<i16, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for i32 {
    type Output = Quantity<i32, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for i64 {
    type Output = Quantity<i64, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for i128 {
    type Output = Quantity<i128, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for isize {
    type Output = Quantity<isize, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for u8 {
    type Output = Quantity<u8, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for u16 {
    type Output = Quantity<u16, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for u32 {
    type Output = Quantity<u32, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for u64 {
    type Output = Quantity<u64, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for u128 {
    type Output = Quantity<u128, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for usize {
    type Output = Quantity<usize, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for f32 {
    type Output = Quantity<f32, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
impl Mul<UnitRontogramForceMul> for f64 {
    type Output = Quantity<f64, UnitRontogramForce>;
    fn mul(self, _: UnitRontogramForceMul) -> Self::Output {
        Quantity::new(self, UnitRontogramForce)
    }
}
pub struct UnitQuectogramForce;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectogramForce {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectogramForce")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectogramForce {
    #[inline]
    fn clone(&self) -> UnitQuectogramForce {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectogramForce {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectogramForce {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectogramForce {
    #[inline]
    fn eq(&self, other: &UnitQuectogramForce) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectogramForce {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectogramForce {
    fn default() -> Self {
        UnitQuectogramForce
    }
}
impl Add<UnitQuectogramForce> for UnitQuectogramForce {
    type Output = UnitQuectogramForce;
    #[inline]
    fn add(self, _: UnitQuectogramForce) -> Self::Output {
        UnitQuectogramForce
    }
}
impl AddAssign<UnitQuectogramForce> for UnitQuectogramForce {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectogramForce) {}
}
impl Sub<UnitQuectogramForce> for UnitQuectogramForce {
    type Output = UnitQuectogramForce;
    #[inline]
    fn sub(self, _: UnitQuectogramForce) -> Self::Output {
        UnitQuectogramForce
    }
}
impl SubAssign<UnitQuectogramForce> for UnitQuectogramForce {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectogramForce) {}
}
pub struct UnitQuectogramForceMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectogramForceMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectogramForceMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectogramForceMul {
    #[inline]
    fn clone(&self) -> UnitQuectogramForceMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectogramForceMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectogramForceMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectogramForceMul {
    #[inline]
    fn eq(&self, other: &UnitQuectogramForceMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectogramForceMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectogramForceMul> for i8 {
    type Output = Quantity<i8, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for i16 {
    type Output = Quantity<i16, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for i32 {
    type Output = Quantity<i32, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for i64 {
    type Output = Quantity<i64, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for i128 {
    type Output = Quantity<i128, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for isize {
    type Output = Quantity<isize, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for u8 {
    type Output = Quantity<u8, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for u16 {
    type Output = Quantity<u16, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for u32 {
    type Output = Quantity<u32, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for u64 {
    type Output = Quantity<u64, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for u128 {
    type Output = Quantity<u128, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for usize {
    type Output = Quantity<usize, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for f32 {
    type Output = Quantity<f32, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
impl Mul<UnitQuectogramForceMul> for f64 {
    type Output = Quantity<f64, UnitQuectogramForce>;
    fn mul(self, _: UnitQuectogramForceMul) -> Self::Output {
        Quantity::new(self, UnitQuectogramForce)
    }
}
pub type GramForce<T> = Quantity<T, UnitGramForce>;
#[allow(non_upper_case_globals)]
pub static GramForce: UnitGramForceMul = UnitGramForceMul;
pub type QuettagramForce<T> = Quantity<T, UnitQuettagramForce>;
#[allow(non_upper_case_globals)]
pub static QuettagramForce: UnitQuettagramForceMul = UnitQuettagramForceMul;
pub type RonnagramForce<T> = Quantity<T, UnitRonnagramForce>;
#[allow(non_upper_case_globals)]
pub static RonnagramForce: UnitRonnagramForceMul = UnitRonnagramForceMul;
pub type YottagramForce<T> = Quantity<T, UnitYottagramForce>;
#[allow(non_upper_case_globals)]
pub static YottagramForce: UnitYottagramForceMul = UnitYottagramForceMul;
pub type ZettagramForce<T> = Quantity<T, UnitZettagramForce>;
#[allow(non_upper_case_globals)]
pub static ZettagramForce: UnitZettagramForceMul = UnitZettagramForceMul;
pub type ExagramForce<T> = Quantity<T, UnitExagramForce>;
#[allow(non_upper_case_globals)]
pub static ExagramForce: UnitExagramForceMul = UnitExagramForceMul;
pub type PetagramForce<T> = Quantity<T, UnitPetagramForce>;
#[allow(non_upper_case_globals)]
pub static PetagramForce: UnitPetagramForceMul = UnitPetagramForceMul;
pub type TeragramForce<T> = Quantity<T, UnitTeragramForce>;
#[allow(non_upper_case_globals)]
pub static TeragramForce: UnitTeragramForceMul = UnitTeragramForceMul;
pub type GigagramForce<T> = Quantity<T, UnitGigagramForce>;
#[allow(non_upper_case_globals)]
pub static GigagramForce: UnitGigagramForceMul = UnitGigagramForceMul;
pub type MegagramForce<T> = Quantity<T, UnitMegagramForce>;
#[allow(non_upper_case_globals)]
pub static MegagramForce: UnitMegagramForceMul = UnitMegagramForceMul;
pub type KilogramForce<T> = Quantity<T, UnitKilogramForce>;
#[allow(non_upper_case_globals)]
pub static KilogramForce: UnitKilogramForceMul = UnitKilogramForceMul;
pub type HectogramForce<T> = Quantity<T, UnitHectogramForce>;
#[allow(non_upper_case_globals)]
pub static HectogramForce: UnitHectogramForceMul = UnitHectogramForceMul;
pub type DecagramForce<T> = Quantity<T, UnitDecagramForce>;
#[allow(non_upper_case_globals)]
pub static DecagramForce: UnitDecagramForceMul = UnitDecagramForceMul;
pub type DecigramForce<T> = Quantity<T, UnitDecigramForce>;
#[allow(non_upper_case_globals)]
pub static DecigramForce: UnitDecigramForceMul = UnitDecigramForceMul;
pub type CentigramForce<T> = Quantity<T, UnitCentigramForce>;
#[allow(non_upper_case_globals)]
pub static CentigramForce: UnitCentigramForceMul = UnitCentigramForceMul;
pub type MilligramForce<T> = Quantity<T, UnitMilligramForce>;
#[allow(non_upper_case_globals)]
pub static MilligramForce: UnitMilligramForceMul = UnitMilligramForceMul;
pub type MicrogramForce<T> = Quantity<T, UnitMicrogramForce>;
#[allow(non_upper_case_globals)]
pub static MicrogramForce: UnitMicrogramForceMul = UnitMicrogramForceMul;
pub type NanogramForce<T> = Quantity<T, UnitNanogramForce>;
#[allow(non_upper_case_globals)]
pub static NanogramForce: UnitNanogramForceMul = UnitNanogramForceMul;
pub type PicogramForce<T> = Quantity<T, UnitPicogramForce>;
#[allow(non_upper_case_globals)]
pub static PicogramForce: UnitPicogramForceMul = UnitPicogramForceMul;
pub type FemtogramForce<T> = Quantity<T, UnitFemtogramForce>;
#[allow(non_upper_case_globals)]
pub static FemtogramForce: UnitFemtogramForceMul = UnitFemtogramForceMul;
pub type AttogramForce<T> = Quantity<T, UnitAttogramForce>;
#[allow(non_upper_case_globals)]
pub static AttogramForce: UnitAttogramForceMul = UnitAttogramForceMul;
pub type ZeptogramForce<T> = Quantity<T, UnitZeptogramForce>;
#[allow(non_upper_case_globals)]
pub static ZeptogramForce: UnitZeptogramForceMul = UnitZeptogramForceMul;
pub type YoctogramForce<T> = Quantity<T, UnitYoctogramForce>;
#[allow(non_upper_case_globals)]
pub static YoctogramForce: UnitYoctogramForceMul = UnitYoctogramForceMul;
pub type RontogramForce<T> = Quantity<T, UnitRontogramForce>;
#[allow(non_upper_case_globals)]
pub static RontogramForce: UnitRontogramForceMul = UnitRontogramForceMul;
pub type QuectogramForce<T> = Quantity<T, UnitQuectogramForce>;
#[allow(non_upper_case_globals)]
pub static QuectogramForce: UnitQuectogramForceMul = UnitQuectogramForceMul;
pub struct UnitHyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHyls {
    #[inline]
    fn clone(&self) -> UnitHyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHyls {
    #[inline]
    fn eq(&self, other: &UnitHyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHyls {
    fn default() -> Self {
        UnitHyls
    }
}
impl Add<UnitHyls> for UnitHyls {
    type Output = UnitHyls;
    #[inline]
    fn add(self, _: UnitHyls) -> Self::Output {
        UnitHyls
    }
}
impl AddAssign<UnitHyls> for UnitHyls {
    #[inline]
    fn add_assign(&mut self, _: UnitHyls) {}
}
impl Sub<UnitHyls> for UnitHyls {
    type Output = UnitHyls;
    #[inline]
    fn sub(self, _: UnitHyls) -> Self::Output {
        UnitHyls
    }
}
impl SubAssign<UnitHyls> for UnitHyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitHyls) {}
}
pub struct UnitHylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHylsMul {
    #[inline]
    fn clone(&self) -> UnitHylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHylsMul {
    #[inline]
    fn eq(&self, other: &UnitHylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHylsMul> for i8 {
    type Output = Quantity<i8, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for i16 {
    type Output = Quantity<i16, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for i32 {
    type Output = Quantity<i32, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for i64 {
    type Output = Quantity<i64, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for i128 {
    type Output = Quantity<i128, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for isize {
    type Output = Quantity<isize, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for u8 {
    type Output = Quantity<u8, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for u16 {
    type Output = Quantity<u16, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for u32 {
    type Output = Quantity<u32, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for u64 {
    type Output = Quantity<u64, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for u128 {
    type Output = Quantity<u128, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for usize {
    type Output = Quantity<usize, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for f32 {
    type Output = Quantity<f32, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
impl Mul<UnitHylsMul> for f64 {
    type Output = Quantity<f64, UnitHyls>;
    fn mul(self, _: UnitHylsMul) -> Self::Output {
        Quantity::new(self, UnitHyls)
    }
}
pub struct UnitQuettahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahyls {
    #[inline]
    fn clone(&self) -> UnitQuettahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahyls {
    #[inline]
    fn eq(&self, other: &UnitQuettahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettahyls {
    fn default() -> Self {
        UnitQuettahyls
    }
}
impl Add<UnitQuettahyls> for UnitQuettahyls {
    type Output = UnitQuettahyls;
    #[inline]
    fn add(self, _: UnitQuettahyls) -> Self::Output {
        UnitQuettahyls
    }
}
impl AddAssign<UnitQuettahyls> for UnitQuettahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettahyls) {}
}
impl Sub<UnitQuettahyls> for UnitQuettahyls {
    type Output = UnitQuettahyls;
    #[inline]
    fn sub(self, _: UnitQuettahyls) -> Self::Output {
        UnitQuettahyls
    }
}
impl SubAssign<UnitQuettahyls> for UnitQuettahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettahyls) {}
}
pub struct UnitQuettahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettahylsMul {
    #[inline]
    fn clone(&self) -> UnitQuettahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettahylsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettahylsMul> for i8 {
    type Output = Quantity<i8, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for i16 {
    type Output = Quantity<i16, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for i32 {
    type Output = Quantity<i32, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for i64 {
    type Output = Quantity<i64, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for i128 {
    type Output = Quantity<i128, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for isize {
    type Output = Quantity<isize, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for u8 {
    type Output = Quantity<u8, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for u16 {
    type Output = Quantity<u16, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for u32 {
    type Output = Quantity<u32, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for u64 {
    type Output = Quantity<u64, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for u128 {
    type Output = Quantity<u128, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for usize {
    type Output = Quantity<usize, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for f32 {
    type Output = Quantity<f32, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
impl Mul<UnitQuettahylsMul> for f64 {
    type Output = Quantity<f64, UnitQuettahyls>;
    fn mul(self, _: UnitQuettahylsMul) -> Self::Output {
        Quantity::new(self, UnitQuettahyls)
    }
}
pub struct UnitRonnahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahyls {
    #[inline]
    fn clone(&self) -> UnitRonnahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahyls {
    #[inline]
    fn eq(&self, other: &UnitRonnahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnahyls {
    fn default() -> Self {
        UnitRonnahyls
    }
}
impl Add<UnitRonnahyls> for UnitRonnahyls {
    type Output = UnitRonnahyls;
    #[inline]
    fn add(self, _: UnitRonnahyls) -> Self::Output {
        UnitRonnahyls
    }
}
impl AddAssign<UnitRonnahyls> for UnitRonnahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnahyls) {}
}
impl Sub<UnitRonnahyls> for UnitRonnahyls {
    type Output = UnitRonnahyls;
    #[inline]
    fn sub(self, _: UnitRonnahyls) -> Self::Output {
        UnitRonnahyls
    }
}
impl SubAssign<UnitRonnahyls> for UnitRonnahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnahyls) {}
}
pub struct UnitRonnahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnahylsMul {
    #[inline]
    fn clone(&self) -> UnitRonnahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnahylsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnahylsMul> for i8 {
    type Output = Quantity<i8, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for i16 {
    type Output = Quantity<i16, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for i32 {
    type Output = Quantity<i32, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for i64 {
    type Output = Quantity<i64, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for i128 {
    type Output = Quantity<i128, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for isize {
    type Output = Quantity<isize, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for u8 {
    type Output = Quantity<u8, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for u16 {
    type Output = Quantity<u16, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for u32 {
    type Output = Quantity<u32, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for u64 {
    type Output = Quantity<u64, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for u128 {
    type Output = Quantity<u128, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for usize {
    type Output = Quantity<usize, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for f32 {
    type Output = Quantity<f32, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
impl Mul<UnitRonnahylsMul> for f64 {
    type Output = Quantity<f64, UnitRonnahyls>;
    fn mul(self, _: UnitRonnahylsMul) -> Self::Output {
        Quantity::new(self, UnitRonnahyls)
    }
}
pub struct UnitYottahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahyls {
    #[inline]
    fn clone(&self) -> UnitYottahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahyls {
    #[inline]
    fn eq(&self, other: &UnitYottahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottahyls {
    fn default() -> Self {
        UnitYottahyls
    }
}
impl Add<UnitYottahyls> for UnitYottahyls {
    type Output = UnitYottahyls;
    #[inline]
    fn add(self, _: UnitYottahyls) -> Self::Output {
        UnitYottahyls
    }
}
impl AddAssign<UnitYottahyls> for UnitYottahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitYottahyls) {}
}
impl Sub<UnitYottahyls> for UnitYottahyls {
    type Output = UnitYottahyls;
    #[inline]
    fn sub(self, _: UnitYottahyls) -> Self::Output {
        UnitYottahyls
    }
}
impl SubAssign<UnitYottahyls> for UnitYottahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottahyls) {}
}
pub struct UnitYottahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottahylsMul {
    #[inline]
    fn clone(&self) -> UnitYottahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottahylsMul {
    #[inline]
    fn eq(&self, other: &UnitYottahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottahylsMul> for i8 {
    type Output = Quantity<i8, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for i16 {
    type Output = Quantity<i16, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for i32 {
    type Output = Quantity<i32, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for i64 {
    type Output = Quantity<i64, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for i128 {
    type Output = Quantity<i128, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for isize {
    type Output = Quantity<isize, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for u8 {
    type Output = Quantity<u8, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for u16 {
    type Output = Quantity<u16, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for u32 {
    type Output = Quantity<u32, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for u64 {
    type Output = Quantity<u64, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for u128 {
    type Output = Quantity<u128, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for usize {
    type Output = Quantity<usize, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for f32 {
    type Output = Quantity<f32, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
impl Mul<UnitYottahylsMul> for f64 {
    type Output = Quantity<f64, UnitYottahyls>;
    fn mul(self, _: UnitYottahylsMul) -> Self::Output {
        Quantity::new(self, UnitYottahyls)
    }
}
pub struct UnitZettahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahyls {
    #[inline]
    fn clone(&self) -> UnitZettahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahyls {
    #[inline]
    fn eq(&self, other: &UnitZettahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettahyls {
    fn default() -> Self {
        UnitZettahyls
    }
}
impl Add<UnitZettahyls> for UnitZettahyls {
    type Output = UnitZettahyls;
    #[inline]
    fn add(self, _: UnitZettahyls) -> Self::Output {
        UnitZettahyls
    }
}
impl AddAssign<UnitZettahyls> for UnitZettahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitZettahyls) {}
}
impl Sub<UnitZettahyls> for UnitZettahyls {
    type Output = UnitZettahyls;
    #[inline]
    fn sub(self, _: UnitZettahyls) -> Self::Output {
        UnitZettahyls
    }
}
impl SubAssign<UnitZettahyls> for UnitZettahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettahyls) {}
}
pub struct UnitZettahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettahylsMul {
    #[inline]
    fn clone(&self) -> UnitZettahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettahylsMul {
    #[inline]
    fn eq(&self, other: &UnitZettahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettahylsMul> for i8 {
    type Output = Quantity<i8, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for i16 {
    type Output = Quantity<i16, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for i32 {
    type Output = Quantity<i32, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for i64 {
    type Output = Quantity<i64, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for i128 {
    type Output = Quantity<i128, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for isize {
    type Output = Quantity<isize, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for u8 {
    type Output = Quantity<u8, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for u16 {
    type Output = Quantity<u16, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for u32 {
    type Output = Quantity<u32, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for u64 {
    type Output = Quantity<u64, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for u128 {
    type Output = Quantity<u128, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for usize {
    type Output = Quantity<usize, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for f32 {
    type Output = Quantity<f32, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
impl Mul<UnitZettahylsMul> for f64 {
    type Output = Quantity<f64, UnitZettahyls>;
    fn mul(self, _: UnitZettahylsMul) -> Self::Output {
        Quantity::new(self, UnitZettahyls)
    }
}
pub struct UnitExahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahyls {
    #[inline]
    fn clone(&self) -> UnitExahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahyls {
    #[inline]
    fn eq(&self, other: &UnitExahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExahyls {
    fn default() -> Self {
        UnitExahyls
    }
}
impl Add<UnitExahyls> for UnitExahyls {
    type Output = UnitExahyls;
    #[inline]
    fn add(self, _: UnitExahyls) -> Self::Output {
        UnitExahyls
    }
}
impl AddAssign<UnitExahyls> for UnitExahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitExahyls) {}
}
impl Sub<UnitExahyls> for UnitExahyls {
    type Output = UnitExahyls;
    #[inline]
    fn sub(self, _: UnitExahyls) -> Self::Output {
        UnitExahyls
    }
}
impl SubAssign<UnitExahyls> for UnitExahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitExahyls) {}
}
pub struct UnitExahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExahylsMul {
    #[inline]
    fn clone(&self) -> UnitExahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExahylsMul {
    #[inline]
    fn eq(&self, other: &UnitExahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExahylsMul> for i8 {
    type Output = Quantity<i8, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for i16 {
    type Output = Quantity<i16, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for i32 {
    type Output = Quantity<i32, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for i64 {
    type Output = Quantity<i64, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for i128 {
    type Output = Quantity<i128, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for isize {
    type Output = Quantity<isize, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for u8 {
    type Output = Quantity<u8, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for u16 {
    type Output = Quantity<u16, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for u32 {
    type Output = Quantity<u32, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for u64 {
    type Output = Quantity<u64, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for u128 {
    type Output = Quantity<u128, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for usize {
    type Output = Quantity<usize, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for f32 {
    type Output = Quantity<f32, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
impl Mul<UnitExahylsMul> for f64 {
    type Output = Quantity<f64, UnitExahyls>;
    fn mul(self, _: UnitExahylsMul) -> Self::Output {
        Quantity::new(self, UnitExahyls)
    }
}
pub struct UnitPetahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahyls {
    #[inline]
    fn clone(&self) -> UnitPetahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahyls {
    #[inline]
    fn eq(&self, other: &UnitPetahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetahyls {
    fn default() -> Self {
        UnitPetahyls
    }
}
impl Add<UnitPetahyls> for UnitPetahyls {
    type Output = UnitPetahyls;
    #[inline]
    fn add(self, _: UnitPetahyls) -> Self::Output {
        UnitPetahyls
    }
}
impl AddAssign<UnitPetahyls> for UnitPetahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitPetahyls) {}
}
impl Sub<UnitPetahyls> for UnitPetahyls {
    type Output = UnitPetahyls;
    #[inline]
    fn sub(self, _: UnitPetahyls) -> Self::Output {
        UnitPetahyls
    }
}
impl SubAssign<UnitPetahyls> for UnitPetahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetahyls) {}
}
pub struct UnitPetahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetahylsMul {
    #[inline]
    fn clone(&self) -> UnitPetahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetahylsMul {
    #[inline]
    fn eq(&self, other: &UnitPetahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetahylsMul> for i8 {
    type Output = Quantity<i8, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for i16 {
    type Output = Quantity<i16, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for i32 {
    type Output = Quantity<i32, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for i64 {
    type Output = Quantity<i64, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for i128 {
    type Output = Quantity<i128, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for isize {
    type Output = Quantity<isize, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for u8 {
    type Output = Quantity<u8, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for u16 {
    type Output = Quantity<u16, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for u32 {
    type Output = Quantity<u32, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for u64 {
    type Output = Quantity<u64, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for u128 {
    type Output = Quantity<u128, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for usize {
    type Output = Quantity<usize, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for f32 {
    type Output = Quantity<f32, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
impl Mul<UnitPetahylsMul> for f64 {
    type Output = Quantity<f64, UnitPetahyls>;
    fn mul(self, _: UnitPetahylsMul) -> Self::Output {
        Quantity::new(self, UnitPetahyls)
    }
}
pub struct UnitTerahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahyls {
    #[inline]
    fn clone(&self) -> UnitTerahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahyls {
    #[inline]
    fn eq(&self, other: &UnitTerahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTerahyls {
    fn default() -> Self {
        UnitTerahyls
    }
}
impl Add<UnitTerahyls> for UnitTerahyls {
    type Output = UnitTerahyls;
    #[inline]
    fn add(self, _: UnitTerahyls) -> Self::Output {
        UnitTerahyls
    }
}
impl AddAssign<UnitTerahyls> for UnitTerahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitTerahyls) {}
}
impl Sub<UnitTerahyls> for UnitTerahyls {
    type Output = UnitTerahyls;
    #[inline]
    fn sub(self, _: UnitTerahyls) -> Self::Output {
        UnitTerahyls
    }
}
impl SubAssign<UnitTerahyls> for UnitTerahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitTerahyls) {}
}
pub struct UnitTerahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTerahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTerahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTerahylsMul {
    #[inline]
    fn clone(&self) -> UnitTerahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTerahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTerahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTerahylsMul {
    #[inline]
    fn eq(&self, other: &UnitTerahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTerahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTerahylsMul> for i8 {
    type Output = Quantity<i8, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for i16 {
    type Output = Quantity<i16, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for i32 {
    type Output = Quantity<i32, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for i64 {
    type Output = Quantity<i64, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for i128 {
    type Output = Quantity<i128, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for isize {
    type Output = Quantity<isize, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for u8 {
    type Output = Quantity<u8, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for u16 {
    type Output = Quantity<u16, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for u32 {
    type Output = Quantity<u32, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for u64 {
    type Output = Quantity<u64, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for u128 {
    type Output = Quantity<u128, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for usize {
    type Output = Quantity<usize, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for f32 {
    type Output = Quantity<f32, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
impl Mul<UnitTerahylsMul> for f64 {
    type Output = Quantity<f64, UnitTerahyls>;
    fn mul(self, _: UnitTerahylsMul) -> Self::Output {
        Quantity::new(self, UnitTerahyls)
    }
}
pub struct UnitGigahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahyls {
    #[inline]
    fn clone(&self) -> UnitGigahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahyls {
    #[inline]
    fn eq(&self, other: &UnitGigahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigahyls {
    fn default() -> Self {
        UnitGigahyls
    }
}
impl Add<UnitGigahyls> for UnitGigahyls {
    type Output = UnitGigahyls;
    #[inline]
    fn add(self, _: UnitGigahyls) -> Self::Output {
        UnitGigahyls
    }
}
impl AddAssign<UnitGigahyls> for UnitGigahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitGigahyls) {}
}
impl Sub<UnitGigahyls> for UnitGigahyls {
    type Output = UnitGigahyls;
    #[inline]
    fn sub(self, _: UnitGigahyls) -> Self::Output {
        UnitGigahyls
    }
}
impl SubAssign<UnitGigahyls> for UnitGigahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigahyls) {}
}
pub struct UnitGigahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigahylsMul {
    #[inline]
    fn clone(&self) -> UnitGigahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigahylsMul {
    #[inline]
    fn eq(&self, other: &UnitGigahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigahylsMul> for i8 {
    type Output = Quantity<i8, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for i16 {
    type Output = Quantity<i16, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for i32 {
    type Output = Quantity<i32, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for i64 {
    type Output = Quantity<i64, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for i128 {
    type Output = Quantity<i128, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for isize {
    type Output = Quantity<isize, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for u8 {
    type Output = Quantity<u8, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for u16 {
    type Output = Quantity<u16, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for u32 {
    type Output = Quantity<u32, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for u64 {
    type Output = Quantity<u64, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for u128 {
    type Output = Quantity<u128, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for usize {
    type Output = Quantity<usize, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for f32 {
    type Output = Quantity<f32, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
impl Mul<UnitGigahylsMul> for f64 {
    type Output = Quantity<f64, UnitGigahyls>;
    fn mul(self, _: UnitGigahylsMul) -> Self::Output {
        Quantity::new(self, UnitGigahyls)
    }
}
pub struct UnitMegahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahyls {
    #[inline]
    fn clone(&self) -> UnitMegahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahyls {
    #[inline]
    fn eq(&self, other: &UnitMegahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegahyls {
    fn default() -> Self {
        UnitMegahyls
    }
}
impl Add<UnitMegahyls> for UnitMegahyls {
    type Output = UnitMegahyls;
    #[inline]
    fn add(self, _: UnitMegahyls) -> Self::Output {
        UnitMegahyls
    }
}
impl AddAssign<UnitMegahyls> for UnitMegahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitMegahyls) {}
}
impl Sub<UnitMegahyls> for UnitMegahyls {
    type Output = UnitMegahyls;
    #[inline]
    fn sub(self, _: UnitMegahyls) -> Self::Output {
        UnitMegahyls
    }
}
impl SubAssign<UnitMegahyls> for UnitMegahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegahyls) {}
}
pub struct UnitMegahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegahylsMul {
    #[inline]
    fn clone(&self) -> UnitMegahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegahylsMul {
    #[inline]
    fn eq(&self, other: &UnitMegahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegahylsMul> for i8 {
    type Output = Quantity<i8, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for i16 {
    type Output = Quantity<i16, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for i32 {
    type Output = Quantity<i32, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for i64 {
    type Output = Quantity<i64, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for i128 {
    type Output = Quantity<i128, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for isize {
    type Output = Quantity<isize, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for u8 {
    type Output = Quantity<u8, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for u16 {
    type Output = Quantity<u16, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for u32 {
    type Output = Quantity<u32, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for u64 {
    type Output = Quantity<u64, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for u128 {
    type Output = Quantity<u128, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for usize {
    type Output = Quantity<usize, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for f32 {
    type Output = Quantity<f32, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
impl Mul<UnitMegahylsMul> for f64 {
    type Output = Quantity<f64, UnitMegahyls>;
    fn mul(self, _: UnitMegahylsMul) -> Self::Output {
        Quantity::new(self, UnitMegahyls)
    }
}
pub struct UnitKilohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohyls {
    #[inline]
    fn clone(&self) -> UnitKilohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohyls {
    #[inline]
    fn eq(&self, other: &UnitKilohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKilohyls {
    fn default() -> Self {
        UnitKilohyls
    }
}
impl Add<UnitKilohyls> for UnitKilohyls {
    type Output = UnitKilohyls;
    #[inline]
    fn add(self, _: UnitKilohyls) -> Self::Output {
        UnitKilohyls
    }
}
impl AddAssign<UnitKilohyls> for UnitKilohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitKilohyls) {}
}
impl Sub<UnitKilohyls> for UnitKilohyls {
    type Output = UnitKilohyls;
    #[inline]
    fn sub(self, _: UnitKilohyls) -> Self::Output {
        UnitKilohyls
    }
}
impl SubAssign<UnitKilohyls> for UnitKilohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitKilohyls) {}
}
pub struct UnitKilohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKilohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKilohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKilohylsMul {
    #[inline]
    fn clone(&self) -> UnitKilohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKilohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKilohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKilohylsMul {
    #[inline]
    fn eq(&self, other: &UnitKilohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKilohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKilohylsMul> for i8 {
    type Output = Quantity<i8, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for i16 {
    type Output = Quantity<i16, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for i32 {
    type Output = Quantity<i32, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for i64 {
    type Output = Quantity<i64, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for i128 {
    type Output = Quantity<i128, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for isize {
    type Output = Quantity<isize, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for u8 {
    type Output = Quantity<u8, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for u16 {
    type Output = Quantity<u16, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for u32 {
    type Output = Quantity<u32, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for u64 {
    type Output = Quantity<u64, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for u128 {
    type Output = Quantity<u128, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for usize {
    type Output = Quantity<usize, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for f32 {
    type Output = Quantity<f32, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
impl Mul<UnitKilohylsMul> for f64 {
    type Output = Quantity<f64, UnitKilohyls>;
    fn mul(self, _: UnitKilohylsMul) -> Self::Output {
        Quantity::new(self, UnitKilohyls)
    }
}
pub struct UnitHectohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohyls {
    #[inline]
    fn clone(&self) -> UnitHectohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohyls {
    #[inline]
    fn eq(&self, other: &UnitHectohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectohyls {
    fn default() -> Self {
        UnitHectohyls
    }
}
impl Add<UnitHectohyls> for UnitHectohyls {
    type Output = UnitHectohyls;
    #[inline]
    fn add(self, _: UnitHectohyls) -> Self::Output {
        UnitHectohyls
    }
}
impl AddAssign<UnitHectohyls> for UnitHectohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitHectohyls) {}
}
impl Sub<UnitHectohyls> for UnitHectohyls {
    type Output = UnitHectohyls;
    #[inline]
    fn sub(self, _: UnitHectohyls) -> Self::Output {
        UnitHectohyls
    }
}
impl SubAssign<UnitHectohyls> for UnitHectohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectohyls) {}
}
pub struct UnitHectohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectohylsMul {
    #[inline]
    fn clone(&self) -> UnitHectohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectohylsMul {
    #[inline]
    fn eq(&self, other: &UnitHectohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectohylsMul> for i8 {
    type Output = Quantity<i8, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for i16 {
    type Output = Quantity<i16, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for i32 {
    type Output = Quantity<i32, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for i64 {
    type Output = Quantity<i64, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for i128 {
    type Output = Quantity<i128, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for isize {
    type Output = Quantity<isize, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for u8 {
    type Output = Quantity<u8, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for u16 {
    type Output = Quantity<u16, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for u32 {
    type Output = Quantity<u32, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for u64 {
    type Output = Quantity<u64, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for u128 {
    type Output = Quantity<u128, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for usize {
    type Output = Quantity<usize, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for f32 {
    type Output = Quantity<f32, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
impl Mul<UnitHectohylsMul> for f64 {
    type Output = Quantity<f64, UnitHectohyls>;
    fn mul(self, _: UnitHectohylsMul) -> Self::Output {
        Quantity::new(self, UnitHectohyls)
    }
}
pub struct UnitDecahyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahyls {
    #[inline]
    fn clone(&self) -> UnitDecahyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahyls {
    #[inline]
    fn eq(&self, other: &UnitDecahyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecahyls {
    fn default() -> Self {
        UnitDecahyls
    }
}
impl Add<UnitDecahyls> for UnitDecahyls {
    type Output = UnitDecahyls;
    #[inline]
    fn add(self, _: UnitDecahyls) -> Self::Output {
        UnitDecahyls
    }
}
impl AddAssign<UnitDecahyls> for UnitDecahyls {
    #[inline]
    fn add_assign(&mut self, _: UnitDecahyls) {}
}
impl Sub<UnitDecahyls> for UnitDecahyls {
    type Output = UnitDecahyls;
    #[inline]
    fn sub(self, _: UnitDecahyls) -> Self::Output {
        UnitDecahyls
    }
}
impl SubAssign<UnitDecahyls> for UnitDecahyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecahyls) {}
}
pub struct UnitDecahylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecahylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecahylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecahylsMul {
    #[inline]
    fn clone(&self) -> UnitDecahylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecahylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecahylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecahylsMul {
    #[inline]
    fn eq(&self, other: &UnitDecahylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecahylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecahylsMul> for i8 {
    type Output = Quantity<i8, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for i16 {
    type Output = Quantity<i16, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for i32 {
    type Output = Quantity<i32, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for i64 {
    type Output = Quantity<i64, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for i128 {
    type Output = Quantity<i128, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for isize {
    type Output = Quantity<isize, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for u8 {
    type Output = Quantity<u8, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for u16 {
    type Output = Quantity<u16, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for u32 {
    type Output = Quantity<u32, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for u64 {
    type Output = Quantity<u64, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for u128 {
    type Output = Quantity<u128, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for usize {
    type Output = Quantity<usize, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for f32 {
    type Output = Quantity<f32, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
impl Mul<UnitDecahylsMul> for f64 {
    type Output = Quantity<f64, UnitDecahyls>;
    fn mul(self, _: UnitDecahylsMul) -> Self::Output {
        Quantity::new(self, UnitDecahyls)
    }
}
pub struct UnitDecihyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihyls {
    #[inline]
    fn clone(&self) -> UnitDecihyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihyls {
    #[inline]
    fn eq(&self, other: &UnitDecihyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecihyls {
    fn default() -> Self {
        UnitDecihyls
    }
}
impl Add<UnitDecihyls> for UnitDecihyls {
    type Output = UnitDecihyls;
    #[inline]
    fn add(self, _: UnitDecihyls) -> Self::Output {
        UnitDecihyls
    }
}
impl AddAssign<UnitDecihyls> for UnitDecihyls {
    #[inline]
    fn add_assign(&mut self, _: UnitDecihyls) {}
}
impl Sub<UnitDecihyls> for UnitDecihyls {
    type Output = UnitDecihyls;
    #[inline]
    fn sub(self, _: UnitDecihyls) -> Self::Output {
        UnitDecihyls
    }
}
impl SubAssign<UnitDecihyls> for UnitDecihyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecihyls) {}
}
pub struct UnitDecihylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecihylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecihylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecihylsMul {
    #[inline]
    fn clone(&self) -> UnitDecihylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecihylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecihylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecihylsMul {
    #[inline]
    fn eq(&self, other: &UnitDecihylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecihylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecihylsMul> for i8 {
    type Output = Quantity<i8, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for i16 {
    type Output = Quantity<i16, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for i32 {
    type Output = Quantity<i32, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for i64 {
    type Output = Quantity<i64, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for i128 {
    type Output = Quantity<i128, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for isize {
    type Output = Quantity<isize, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for u8 {
    type Output = Quantity<u8, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for u16 {
    type Output = Quantity<u16, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for u32 {
    type Output = Quantity<u32, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for u64 {
    type Output = Quantity<u64, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for u128 {
    type Output = Quantity<u128, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for usize {
    type Output = Quantity<usize, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for f32 {
    type Output = Quantity<f32, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
impl Mul<UnitDecihylsMul> for f64 {
    type Output = Quantity<f64, UnitDecihyls>;
    fn mul(self, _: UnitDecihylsMul) -> Self::Output {
        Quantity::new(self, UnitDecihyls)
    }
}
pub struct UnitCentihyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihyls {
    #[inline]
    fn clone(&self) -> UnitCentihyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihyls {
    #[inline]
    fn eq(&self, other: &UnitCentihyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentihyls {
    fn default() -> Self {
        UnitCentihyls
    }
}
impl Add<UnitCentihyls> for UnitCentihyls {
    type Output = UnitCentihyls;
    #[inline]
    fn add(self, _: UnitCentihyls) -> Self::Output {
        UnitCentihyls
    }
}
impl AddAssign<UnitCentihyls> for UnitCentihyls {
    #[inline]
    fn add_assign(&mut self, _: UnitCentihyls) {}
}
impl Sub<UnitCentihyls> for UnitCentihyls {
    type Output = UnitCentihyls;
    #[inline]
    fn sub(self, _: UnitCentihyls) -> Self::Output {
        UnitCentihyls
    }
}
impl SubAssign<UnitCentihyls> for UnitCentihyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentihyls) {}
}
pub struct UnitCentihylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentihylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentihylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentihylsMul {
    #[inline]
    fn clone(&self) -> UnitCentihylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentihylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentihylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentihylsMul {
    #[inline]
    fn eq(&self, other: &UnitCentihylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentihylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentihylsMul> for i8 {
    type Output = Quantity<i8, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for i16 {
    type Output = Quantity<i16, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for i32 {
    type Output = Quantity<i32, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for i64 {
    type Output = Quantity<i64, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for i128 {
    type Output = Quantity<i128, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for isize {
    type Output = Quantity<isize, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for u8 {
    type Output = Quantity<u8, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for u16 {
    type Output = Quantity<u16, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for u32 {
    type Output = Quantity<u32, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for u64 {
    type Output = Quantity<u64, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for u128 {
    type Output = Quantity<u128, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for usize {
    type Output = Quantity<usize, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for f32 {
    type Output = Quantity<f32, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
impl Mul<UnitCentihylsMul> for f64 {
    type Output = Quantity<f64, UnitCentihyls>;
    fn mul(self, _: UnitCentihylsMul) -> Self::Output {
        Quantity::new(self, UnitCentihyls)
    }
}
pub struct UnitMillihyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihyls {
    #[inline]
    fn clone(&self) -> UnitMillihyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihyls {
    #[inline]
    fn eq(&self, other: &UnitMillihyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMillihyls {
    fn default() -> Self {
        UnitMillihyls
    }
}
impl Add<UnitMillihyls> for UnitMillihyls {
    type Output = UnitMillihyls;
    #[inline]
    fn add(self, _: UnitMillihyls) -> Self::Output {
        UnitMillihyls
    }
}
impl AddAssign<UnitMillihyls> for UnitMillihyls {
    #[inline]
    fn add_assign(&mut self, _: UnitMillihyls) {}
}
impl Sub<UnitMillihyls> for UnitMillihyls {
    type Output = UnitMillihyls;
    #[inline]
    fn sub(self, _: UnitMillihyls) -> Self::Output {
        UnitMillihyls
    }
}
impl SubAssign<UnitMillihyls> for UnitMillihyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMillihyls) {}
}
pub struct UnitMillihylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMillihylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMillihylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMillihylsMul {
    #[inline]
    fn clone(&self) -> UnitMillihylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMillihylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMillihylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMillihylsMul {
    #[inline]
    fn eq(&self, other: &UnitMillihylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMillihylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMillihylsMul> for i8 {
    type Output = Quantity<i8, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for i16 {
    type Output = Quantity<i16, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for i32 {
    type Output = Quantity<i32, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for i64 {
    type Output = Quantity<i64, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for i128 {
    type Output = Quantity<i128, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for isize {
    type Output = Quantity<isize, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for u8 {
    type Output = Quantity<u8, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for u16 {
    type Output = Quantity<u16, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for u32 {
    type Output = Quantity<u32, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for u64 {
    type Output = Quantity<u64, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for u128 {
    type Output = Quantity<u128, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for usize {
    type Output = Quantity<usize, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for f32 {
    type Output = Quantity<f32, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
impl Mul<UnitMillihylsMul> for f64 {
    type Output = Quantity<f64, UnitMillihyls>;
    fn mul(self, _: UnitMillihylsMul) -> Self::Output {
        Quantity::new(self, UnitMillihyls)
    }
}
pub struct UnitMicrohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohyls {
    #[inline]
    fn clone(&self) -> UnitMicrohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohyls {
    #[inline]
    fn eq(&self, other: &UnitMicrohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicrohyls {
    fn default() -> Self {
        UnitMicrohyls
    }
}
impl Add<UnitMicrohyls> for UnitMicrohyls {
    type Output = UnitMicrohyls;
    #[inline]
    fn add(self, _: UnitMicrohyls) -> Self::Output {
        UnitMicrohyls
    }
}
impl AddAssign<UnitMicrohyls> for UnitMicrohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitMicrohyls) {}
}
impl Sub<UnitMicrohyls> for UnitMicrohyls {
    type Output = UnitMicrohyls;
    #[inline]
    fn sub(self, _: UnitMicrohyls) -> Self::Output {
        UnitMicrohyls
    }
}
impl SubAssign<UnitMicrohyls> for UnitMicrohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicrohyls) {}
}
pub struct UnitMicrohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicrohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicrohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicrohylsMul {
    #[inline]
    fn clone(&self) -> UnitMicrohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicrohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicrohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicrohylsMul {
    #[inline]
    fn eq(&self, other: &UnitMicrohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicrohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicrohylsMul> for i8 {
    type Output = Quantity<i8, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for i16 {
    type Output = Quantity<i16, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for i32 {
    type Output = Quantity<i32, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for i64 {
    type Output = Quantity<i64, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for i128 {
    type Output = Quantity<i128, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for isize {
    type Output = Quantity<isize, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for u8 {
    type Output = Quantity<u8, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for u16 {
    type Output = Quantity<u16, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for u32 {
    type Output = Quantity<u32, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for u64 {
    type Output = Quantity<u64, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for u128 {
    type Output = Quantity<u128, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for usize {
    type Output = Quantity<usize, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for f32 {
    type Output = Quantity<f32, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
impl Mul<UnitMicrohylsMul> for f64 {
    type Output = Quantity<f64, UnitMicrohyls>;
    fn mul(self, _: UnitMicrohylsMul) -> Self::Output {
        Quantity::new(self, UnitMicrohyls)
    }
}
pub struct UnitNanohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohyls {
    #[inline]
    fn clone(&self) -> UnitNanohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohyls {
    #[inline]
    fn eq(&self, other: &UnitNanohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanohyls {
    fn default() -> Self {
        UnitNanohyls
    }
}
impl Add<UnitNanohyls> for UnitNanohyls {
    type Output = UnitNanohyls;
    #[inline]
    fn add(self, _: UnitNanohyls) -> Self::Output {
        UnitNanohyls
    }
}
impl AddAssign<UnitNanohyls> for UnitNanohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitNanohyls) {}
}
impl Sub<UnitNanohyls> for UnitNanohyls {
    type Output = UnitNanohyls;
    #[inline]
    fn sub(self, _: UnitNanohyls) -> Self::Output {
        UnitNanohyls
    }
}
impl SubAssign<UnitNanohyls> for UnitNanohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanohyls) {}
}
pub struct UnitNanohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanohylsMul {
    #[inline]
    fn clone(&self) -> UnitNanohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanohylsMul {
    #[inline]
    fn eq(&self, other: &UnitNanohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanohylsMul> for i8 {
    type Output = Quantity<i8, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for i16 {
    type Output = Quantity<i16, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for i32 {
    type Output = Quantity<i32, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for i64 {
    type Output = Quantity<i64, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for i128 {
    type Output = Quantity<i128, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for isize {
    type Output = Quantity<isize, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for u8 {
    type Output = Quantity<u8, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for u16 {
    type Output = Quantity<u16, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for u32 {
    type Output = Quantity<u32, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for u64 {
    type Output = Quantity<u64, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for u128 {
    type Output = Quantity<u128, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for usize {
    type Output = Quantity<usize, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for f32 {
    type Output = Quantity<f32, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
impl Mul<UnitNanohylsMul> for f64 {
    type Output = Quantity<f64, UnitNanohyls>;
    fn mul(self, _: UnitNanohylsMul) -> Self::Output {
        Quantity::new(self, UnitNanohyls)
    }
}
pub struct UnitPicohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohyls {
    #[inline]
    fn clone(&self) -> UnitPicohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohyls {
    #[inline]
    fn eq(&self, other: &UnitPicohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicohyls {
    fn default() -> Self {
        UnitPicohyls
    }
}
impl Add<UnitPicohyls> for UnitPicohyls {
    type Output = UnitPicohyls;
    #[inline]
    fn add(self, _: UnitPicohyls) -> Self::Output {
        UnitPicohyls
    }
}
impl AddAssign<UnitPicohyls> for UnitPicohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitPicohyls) {}
}
impl Sub<UnitPicohyls> for UnitPicohyls {
    type Output = UnitPicohyls;
    #[inline]
    fn sub(self, _: UnitPicohyls) -> Self::Output {
        UnitPicohyls
    }
}
impl SubAssign<UnitPicohyls> for UnitPicohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicohyls) {}
}
pub struct UnitPicohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicohylsMul {
    #[inline]
    fn clone(&self) -> UnitPicohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicohylsMul {
    #[inline]
    fn eq(&self, other: &UnitPicohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicohylsMul> for i8 {
    type Output = Quantity<i8, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for i16 {
    type Output = Quantity<i16, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for i32 {
    type Output = Quantity<i32, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for i64 {
    type Output = Quantity<i64, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for i128 {
    type Output = Quantity<i128, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for isize {
    type Output = Quantity<isize, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for u8 {
    type Output = Quantity<u8, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for u16 {
    type Output = Quantity<u16, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for u32 {
    type Output = Quantity<u32, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for u64 {
    type Output = Quantity<u64, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for u128 {
    type Output = Quantity<u128, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for usize {
    type Output = Quantity<usize, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for f32 {
    type Output = Quantity<f32, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
impl Mul<UnitPicohylsMul> for f64 {
    type Output = Quantity<f64, UnitPicohyls>;
    fn mul(self, _: UnitPicohylsMul) -> Self::Output {
        Quantity::new(self, UnitPicohyls)
    }
}
pub struct UnitFemtohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohyls {
    #[inline]
    fn clone(&self) -> UnitFemtohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohyls {
    #[inline]
    fn eq(&self, other: &UnitFemtohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtohyls {
    fn default() -> Self {
        UnitFemtohyls
    }
}
impl Add<UnitFemtohyls> for UnitFemtohyls {
    type Output = UnitFemtohyls;
    #[inline]
    fn add(self, _: UnitFemtohyls) -> Self::Output {
        UnitFemtohyls
    }
}
impl AddAssign<UnitFemtohyls> for UnitFemtohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtohyls) {}
}
impl Sub<UnitFemtohyls> for UnitFemtohyls {
    type Output = UnitFemtohyls;
    #[inline]
    fn sub(self, _: UnitFemtohyls) -> Self::Output {
        UnitFemtohyls
    }
}
impl SubAssign<UnitFemtohyls> for UnitFemtohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtohyls) {}
}
pub struct UnitFemtohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtohylsMul {
    #[inline]
    fn clone(&self) -> UnitFemtohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtohylsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtohylsMul> for i8 {
    type Output = Quantity<i8, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for i16 {
    type Output = Quantity<i16, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for i32 {
    type Output = Quantity<i32, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for i64 {
    type Output = Quantity<i64, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for i128 {
    type Output = Quantity<i128, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for isize {
    type Output = Quantity<isize, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for u8 {
    type Output = Quantity<u8, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for u16 {
    type Output = Quantity<u16, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for u32 {
    type Output = Quantity<u32, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for u64 {
    type Output = Quantity<u64, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for u128 {
    type Output = Quantity<u128, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for usize {
    type Output = Quantity<usize, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for f32 {
    type Output = Quantity<f32, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
impl Mul<UnitFemtohylsMul> for f64 {
    type Output = Quantity<f64, UnitFemtohyls>;
    fn mul(self, _: UnitFemtohylsMul) -> Self::Output {
        Quantity::new(self, UnitFemtohyls)
    }
}
pub struct UnitAttohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohyls {
    #[inline]
    fn clone(&self) -> UnitAttohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohyls {
    #[inline]
    fn eq(&self, other: &UnitAttohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttohyls {
    fn default() -> Self {
        UnitAttohyls
    }
}
impl Add<UnitAttohyls> for UnitAttohyls {
    type Output = UnitAttohyls;
    #[inline]
    fn add(self, _: UnitAttohyls) -> Self::Output {
        UnitAttohyls
    }
}
impl AddAssign<UnitAttohyls> for UnitAttohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitAttohyls) {}
}
impl Sub<UnitAttohyls> for UnitAttohyls {
    type Output = UnitAttohyls;
    #[inline]
    fn sub(self, _: UnitAttohyls) -> Self::Output {
        UnitAttohyls
    }
}
impl SubAssign<UnitAttohyls> for UnitAttohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttohyls) {}
}
pub struct UnitAttohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttohylsMul {
    #[inline]
    fn clone(&self) -> UnitAttohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttohylsMul {
    #[inline]
    fn eq(&self, other: &UnitAttohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttohylsMul> for i8 {
    type Output = Quantity<i8, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for i16 {
    type Output = Quantity<i16, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for i32 {
    type Output = Quantity<i32, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for i64 {
    type Output = Quantity<i64, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for i128 {
    type Output = Quantity<i128, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for isize {
    type Output = Quantity<isize, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for u8 {
    type Output = Quantity<u8, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for u16 {
    type Output = Quantity<u16, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for u32 {
    type Output = Quantity<u32, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for u64 {
    type Output = Quantity<u64, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for u128 {
    type Output = Quantity<u128, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for usize {
    type Output = Quantity<usize, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for f32 {
    type Output = Quantity<f32, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
impl Mul<UnitAttohylsMul> for f64 {
    type Output = Quantity<f64, UnitAttohyls>;
    fn mul(self, _: UnitAttohylsMul) -> Self::Output {
        Quantity::new(self, UnitAttohyls)
    }
}
pub struct UnitZeptohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohyls {
    #[inline]
    fn clone(&self) -> UnitZeptohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohyls {
    #[inline]
    fn eq(&self, other: &UnitZeptohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptohyls {
    fn default() -> Self {
        UnitZeptohyls
    }
}
impl Add<UnitZeptohyls> for UnitZeptohyls {
    type Output = UnitZeptohyls;
    #[inline]
    fn add(self, _: UnitZeptohyls) -> Self::Output {
        UnitZeptohyls
    }
}
impl AddAssign<UnitZeptohyls> for UnitZeptohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptohyls) {}
}
impl Sub<UnitZeptohyls> for UnitZeptohyls {
    type Output = UnitZeptohyls;
    #[inline]
    fn sub(self, _: UnitZeptohyls) -> Self::Output {
        UnitZeptohyls
    }
}
impl SubAssign<UnitZeptohyls> for UnitZeptohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptohyls) {}
}
pub struct UnitZeptohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptohylsMul {
    #[inline]
    fn clone(&self) -> UnitZeptohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptohylsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptohylsMul> for i8 {
    type Output = Quantity<i8, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for i16 {
    type Output = Quantity<i16, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for i32 {
    type Output = Quantity<i32, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for i64 {
    type Output = Quantity<i64, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for i128 {
    type Output = Quantity<i128, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for isize {
    type Output = Quantity<isize, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for u8 {
    type Output = Quantity<u8, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for u16 {
    type Output = Quantity<u16, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for u32 {
    type Output = Quantity<u32, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for u64 {
    type Output = Quantity<u64, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for u128 {
    type Output = Quantity<u128, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for usize {
    type Output = Quantity<usize, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for f32 {
    type Output = Quantity<f32, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
impl Mul<UnitZeptohylsMul> for f64 {
    type Output = Quantity<f64, UnitZeptohyls>;
    fn mul(self, _: UnitZeptohylsMul) -> Self::Output {
        Quantity::new(self, UnitZeptohyls)
    }
}
pub struct UnitYoctohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohyls {
    #[inline]
    fn clone(&self) -> UnitYoctohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohyls {
    #[inline]
    fn eq(&self, other: &UnitYoctohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctohyls {
    fn default() -> Self {
        UnitYoctohyls
    }
}
impl Add<UnitYoctohyls> for UnitYoctohyls {
    type Output = UnitYoctohyls;
    #[inline]
    fn add(self, _: UnitYoctohyls) -> Self::Output {
        UnitYoctohyls
    }
}
impl AddAssign<UnitYoctohyls> for UnitYoctohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctohyls) {}
}
impl Sub<UnitYoctohyls> for UnitYoctohyls {
    type Output = UnitYoctohyls;
    #[inline]
    fn sub(self, _: UnitYoctohyls) -> Self::Output {
        UnitYoctohyls
    }
}
impl SubAssign<UnitYoctohyls> for UnitYoctohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctohyls) {}
}
pub struct UnitYoctohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctohylsMul {
    #[inline]
    fn clone(&self) -> UnitYoctohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctohylsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctohylsMul> for i8 {
    type Output = Quantity<i8, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for i16 {
    type Output = Quantity<i16, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for i32 {
    type Output = Quantity<i32, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for i64 {
    type Output = Quantity<i64, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for i128 {
    type Output = Quantity<i128, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for isize {
    type Output = Quantity<isize, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for u8 {
    type Output = Quantity<u8, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for u16 {
    type Output = Quantity<u16, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for u32 {
    type Output = Quantity<u32, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for u64 {
    type Output = Quantity<u64, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for u128 {
    type Output = Quantity<u128, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for usize {
    type Output = Quantity<usize, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for f32 {
    type Output = Quantity<f32, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
impl Mul<UnitYoctohylsMul> for f64 {
    type Output = Quantity<f64, UnitYoctohyls>;
    fn mul(self, _: UnitYoctohylsMul) -> Self::Output {
        Quantity::new(self, UnitYoctohyls)
    }
}
pub struct UnitRontohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohyls {
    #[inline]
    fn clone(&self) -> UnitRontohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohyls {
    #[inline]
    fn eq(&self, other: &UnitRontohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontohyls {
    fn default() -> Self {
        UnitRontohyls
    }
}
impl Add<UnitRontohyls> for UnitRontohyls {
    type Output = UnitRontohyls;
    #[inline]
    fn add(self, _: UnitRontohyls) -> Self::Output {
        UnitRontohyls
    }
}
impl AddAssign<UnitRontohyls> for UnitRontohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitRontohyls) {}
}
impl Sub<UnitRontohyls> for UnitRontohyls {
    type Output = UnitRontohyls;
    #[inline]
    fn sub(self, _: UnitRontohyls) -> Self::Output {
        UnitRontohyls
    }
}
impl SubAssign<UnitRontohyls> for UnitRontohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontohyls) {}
}
pub struct UnitRontohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontohylsMul {
    #[inline]
    fn clone(&self) -> UnitRontohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontohylsMul {
    #[inline]
    fn eq(&self, other: &UnitRontohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontohylsMul> for i8 {
    type Output = Quantity<i8, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for i16 {
    type Output = Quantity<i16, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for i32 {
    type Output = Quantity<i32, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for i64 {
    type Output = Quantity<i64, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for i128 {
    type Output = Quantity<i128, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for isize {
    type Output = Quantity<isize, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for u8 {
    type Output = Quantity<u8, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for u16 {
    type Output = Quantity<u16, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for u32 {
    type Output = Quantity<u32, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for u64 {
    type Output = Quantity<u64, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for u128 {
    type Output = Quantity<u128, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for usize {
    type Output = Quantity<usize, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for f32 {
    type Output = Quantity<f32, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
impl Mul<UnitRontohylsMul> for f64 {
    type Output = Quantity<f64, UnitRontohyls>;
    fn mul(self, _: UnitRontohylsMul) -> Self::Output {
        Quantity::new(self, UnitRontohyls)
    }
}
pub struct UnitQuectohyls;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohyls {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohyls")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohyls {
    #[inline]
    fn clone(&self) -> UnitQuectohyls {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohyls {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohyls {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohyls {
    #[inline]
    fn eq(&self, other: &UnitQuectohyls) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohyls {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectohyls {
    fn default() -> Self {
        UnitQuectohyls
    }
}
impl Add<UnitQuectohyls> for UnitQuectohyls {
    type Output = UnitQuectohyls;
    #[inline]
    fn add(self, _: UnitQuectohyls) -> Self::Output {
        UnitQuectohyls
    }
}
impl AddAssign<UnitQuectohyls> for UnitQuectohyls {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectohyls) {}
}
impl Sub<UnitQuectohyls> for UnitQuectohyls {
    type Output = UnitQuectohyls;
    #[inline]
    fn sub(self, _: UnitQuectohyls) -> Self::Output {
        UnitQuectohyls
    }
}
impl SubAssign<UnitQuectohyls> for UnitQuectohyls {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectohyls) {}
}
pub struct UnitQuectohylsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectohylsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectohylsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectohylsMul {
    #[inline]
    fn clone(&self) -> UnitQuectohylsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectohylsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectohylsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectohylsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectohylsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectohylsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectohylsMul> for i8 {
    type Output = Quantity<i8, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for i16 {
    type Output = Quantity<i16, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for i32 {
    type Output = Quantity<i32, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for i64 {
    type Output = Quantity<i64, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for i128 {
    type Output = Quantity<i128, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for isize {
    type Output = Quantity<isize, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for u8 {
    type Output = Quantity<u8, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for u16 {
    type Output = Quantity<u16, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for u32 {
    type Output = Quantity<u32, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for u64 {
    type Output = Quantity<u64, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for u128 {
    type Output = Quantity<u128, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for usize {
    type Output = Quantity<usize, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for f32 {
    type Output = Quantity<f32, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
impl Mul<UnitQuectohylsMul> for f64 {
    type Output = Quantity<f64, UnitQuectohyls>;
    fn mul(self, _: UnitQuectohylsMul) -> Self::Output {
        Quantity::new(self, UnitQuectohyls)
    }
}
pub type Hyls<T> = Quantity<T, UnitHyls>;
#[allow(non_upper_case_globals)]
pub static Hyls: UnitHylsMul = UnitHylsMul;
pub type Quettahyls<T> = Quantity<T, UnitQuettahyls>;
#[allow(non_upper_case_globals)]
pub static Quettahyls: UnitQuettahylsMul = UnitQuettahylsMul;
pub type Ronnahyls<T> = Quantity<T, UnitRonnahyls>;
#[allow(non_upper_case_globals)]
pub static Ronnahyls: UnitRonnahylsMul = UnitRonnahylsMul;
pub type Yottahyls<T> = Quantity<T, UnitYottahyls>;
#[allow(non_upper_case_globals)]
pub static Yottahyls: UnitYottahylsMul = UnitYottahylsMul;
pub type Zettahyls<T> = Quantity<T, UnitZettahyls>;
#[allow(non_upper_case_globals)]
pub static Zettahyls: UnitZettahylsMul = UnitZettahylsMul;
pub type Exahyls<T> = Quantity<T, UnitExahyls>;
#[allow(non_upper_case_globals)]
pub static Exahyls: UnitExahylsMul = UnitExahylsMul;
pub type Petahyls<T> = Quantity<T, UnitPetahyls>;
#[allow(non_upper_case_globals)]
pub static Petahyls: UnitPetahylsMul = UnitPetahylsMul;
pub type Terahyls<T> = Quantity<T, UnitTerahyls>;
#[allow(non_upper_case_globals)]
pub static Terahyls: UnitTerahylsMul = UnitTerahylsMul;
pub type Gigahyls<T> = Quantity<T, UnitGigahyls>;
#[allow(non_upper_case_globals)]
pub static Gigahyls: UnitGigahylsMul = UnitGigahylsMul;
pub type Megahyls<T> = Quantity<T, UnitMegahyls>;
#[allow(non_upper_case_globals)]
pub static Megahyls: UnitMegahylsMul = UnitMegahylsMul;
pub type Kilohyls<T> = Quantity<T, UnitKilohyls>;
#[allow(non_upper_case_globals)]
pub static Kilohyls: UnitKilohylsMul = UnitKilohylsMul;
pub type Hectohyls<T> = Quantity<T, UnitHectohyls>;
#[allow(non_upper_case_globals)]
pub static Hectohyls: UnitHectohylsMul = UnitHectohylsMul;
pub type Decahyls<T> = Quantity<T, UnitDecahyls>;
#[allow(non_upper_case_globals)]
pub static Decahyls: UnitDecahylsMul = UnitDecahylsMul;
pub type Decihyls<T> = Quantity<T, UnitDecihyls>;
#[allow(non_upper_case_globals)]
pub static Decihyls: UnitDecihylsMul = UnitDecihylsMul;
pub type Centihyls<T> = Quantity<T, UnitCentihyls>;
#[allow(non_upper_case_globals)]
pub static Centihyls: UnitCentihylsMul = UnitCentihylsMul;
pub type Millihyls<T> = Quantity<T, UnitMillihyls>;
#[allow(non_upper_case_globals)]
pub static Millihyls: UnitMillihylsMul = UnitMillihylsMul;
pub type Microhyls<T> = Quantity<T, UnitMicrohyls>;
#[allow(non_upper_case_globals)]
pub static Microhyls: UnitMicrohylsMul = UnitMicrohylsMul;
pub type Nanohyls<T> = Quantity<T, UnitNanohyls>;
#[allow(non_upper_case_globals)]
pub static Nanohyls: UnitNanohylsMul = UnitNanohylsMul;
pub type Picohyls<T> = Quantity<T, UnitPicohyls>;
#[allow(non_upper_case_globals)]
pub static Picohyls: UnitPicohylsMul = UnitPicohylsMul;
pub type Femtohyls<T> = Quantity<T, UnitFemtohyls>;
#[allow(non_upper_case_globals)]
pub static Femtohyls: UnitFemtohylsMul = UnitFemtohylsMul;
pub type Attohyls<T> = Quantity<T, UnitAttohyls>;
#[allow(non_upper_case_globals)]
pub static Attohyls: UnitAttohylsMul = UnitAttohylsMul;
pub type Zeptohyls<T> = Quantity<T, UnitZeptohyls>;
#[allow(non_upper_case_globals)]
pub static Zeptohyls: UnitZeptohylsMul = UnitZeptohylsMul;
pub type Yoctohyls<T> = Quantity<T, UnitYoctohyls>;
#[allow(non_upper_case_globals)]
pub static Yoctohyls: UnitYoctohylsMul = UnitYoctohylsMul;
pub type Rontohyls<T> = Quantity<T, UnitRontohyls>;
#[allow(non_upper_case_globals)]
pub static Rontohyls: UnitRontohylsMul = UnitRontohylsMul;
pub type Quectohyls<T> = Quantity<T, UnitQuectohyls>;
#[allow(non_upper_case_globals)]
pub static Quectohyls: UnitQuectohylsMul = UnitQuectohylsMul;
pub struct UnitPoncelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPoncelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPoncelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPoncelets {
    #[inline]
    fn clone(&self) -> UnitPoncelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPoncelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPoncelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPoncelets {
    #[inline]
    fn eq(&self, other: &UnitPoncelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPoncelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPoncelets {
    fn default() -> Self {
        UnitPoncelets
    }
}
impl Add<UnitPoncelets> for UnitPoncelets {
    type Output = UnitPoncelets;
    #[inline]
    fn add(self, _: UnitPoncelets) -> Self::Output {
        UnitPoncelets
    }
}
impl AddAssign<UnitPoncelets> for UnitPoncelets {
    #[inline]
    fn add_assign(&mut self, _: UnitPoncelets) {}
}
impl Sub<UnitPoncelets> for UnitPoncelets {
    type Output = UnitPoncelets;
    #[inline]
    fn sub(self, _: UnitPoncelets) -> Self::Output {
        UnitPoncelets
    }
}
impl SubAssign<UnitPoncelets> for UnitPoncelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitPoncelets) {}
}
pub struct UnitPonceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPonceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPonceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPonceletsMul {
    #[inline]
    fn clone(&self) -> UnitPonceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPonceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPonceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPonceletsMul {
    #[inline]
    fn eq(&self, other: &UnitPonceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPonceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPonceletsMul> for i8 {
    type Output = Quantity<i8, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for i16 {
    type Output = Quantity<i16, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for i32 {
    type Output = Quantity<i32, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for i64 {
    type Output = Quantity<i64, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for i128 {
    type Output = Quantity<i128, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for isize {
    type Output = Quantity<isize, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for u8 {
    type Output = Quantity<u8, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for u16 {
    type Output = Quantity<u16, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for u32 {
    type Output = Quantity<u32, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for u64 {
    type Output = Quantity<u64, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for u128 {
    type Output = Quantity<u128, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for usize {
    type Output = Quantity<usize, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for f32 {
    type Output = Quantity<f32, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
impl Mul<UnitPonceletsMul> for f64 {
    type Output = Quantity<f64, UnitPoncelets>;
    fn mul(self, _: UnitPonceletsMul) -> Self::Output {
        Quantity::new(self, UnitPoncelets)
    }
}
pub struct UnitQuettaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaponcelets {
    #[inline]
    fn clone(&self) -> UnitQuettaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaponcelets {
    #[inline]
    fn eq(&self, other: &UnitQuettaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuettaponcelets {
    fn default() -> Self {
        UnitQuettaponcelets
    }
}
impl Add<UnitQuettaponcelets> for UnitQuettaponcelets {
    type Output = UnitQuettaponcelets;
    #[inline]
    fn add(self, _: UnitQuettaponcelets) -> Self::Output {
        UnitQuettaponcelets
    }
}
impl AddAssign<UnitQuettaponcelets> for UnitQuettaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitQuettaponcelets) {}
}
impl Sub<UnitQuettaponcelets> for UnitQuettaponcelets {
    type Output = UnitQuettaponcelets;
    #[inline]
    fn sub(self, _: UnitQuettaponcelets) -> Self::Output {
        UnitQuettaponcelets
    }
}
impl SubAssign<UnitQuettaponcelets> for UnitQuettaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuettaponcelets) {}
}
pub struct UnitQuettaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuettaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuettaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuettaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitQuettaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuettaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuettaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuettaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitQuettaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuettaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuettaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for isize {
    type Output = Quantity<isize, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for usize {
    type Output = Quantity<usize, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
impl Mul<UnitQuettaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitQuettaponcelets>;
    fn mul(self, _: UnitQuettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuettaponcelets)
    }
}
pub struct UnitRonnaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaponcelets {
    #[inline]
    fn clone(&self) -> UnitRonnaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaponcelets {
    #[inline]
    fn eq(&self, other: &UnitRonnaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRonnaponcelets {
    fn default() -> Self {
        UnitRonnaponcelets
    }
}
impl Add<UnitRonnaponcelets> for UnitRonnaponcelets {
    type Output = UnitRonnaponcelets;
    #[inline]
    fn add(self, _: UnitRonnaponcelets) -> Self::Output {
        UnitRonnaponcelets
    }
}
impl AddAssign<UnitRonnaponcelets> for UnitRonnaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitRonnaponcelets) {}
}
impl Sub<UnitRonnaponcelets> for UnitRonnaponcelets {
    type Output = UnitRonnaponcelets;
    #[inline]
    fn sub(self, _: UnitRonnaponcelets) -> Self::Output {
        UnitRonnaponcelets
    }
}
impl SubAssign<UnitRonnaponcelets> for UnitRonnaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitRonnaponcelets) {}
}
pub struct UnitRonnaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRonnaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRonnaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRonnaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitRonnaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRonnaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRonnaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRonnaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitRonnaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRonnaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRonnaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for isize {
    type Output = Quantity<isize, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for usize {
    type Output = Quantity<usize, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
impl Mul<UnitRonnaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitRonnaponcelets>;
    fn mul(self, _: UnitRonnaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRonnaponcelets)
    }
}
pub struct UnitYottaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaponcelets {
    #[inline]
    fn clone(&self) -> UnitYottaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaponcelets {
    #[inline]
    fn eq(&self, other: &UnitYottaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYottaponcelets {
    fn default() -> Self {
        UnitYottaponcelets
    }
}
impl Add<UnitYottaponcelets> for UnitYottaponcelets {
    type Output = UnitYottaponcelets;
    #[inline]
    fn add(self, _: UnitYottaponcelets) -> Self::Output {
        UnitYottaponcelets
    }
}
impl AddAssign<UnitYottaponcelets> for UnitYottaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitYottaponcelets) {}
}
impl Sub<UnitYottaponcelets> for UnitYottaponcelets {
    type Output = UnitYottaponcelets;
    #[inline]
    fn sub(self, _: UnitYottaponcelets) -> Self::Output {
        UnitYottaponcelets
    }
}
impl SubAssign<UnitYottaponcelets> for UnitYottaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitYottaponcelets) {}
}
pub struct UnitYottaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYottaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYottaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYottaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitYottaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYottaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYottaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYottaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitYottaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYottaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYottaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for isize {
    type Output = Quantity<isize, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for usize {
    type Output = Quantity<usize, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
impl Mul<UnitYottaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitYottaponcelets>;
    fn mul(self, _: UnitYottaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYottaponcelets)
    }
}
pub struct UnitZettaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaponcelets {
    #[inline]
    fn clone(&self) -> UnitZettaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaponcelets {
    #[inline]
    fn eq(&self, other: &UnitZettaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZettaponcelets {
    fn default() -> Self {
        UnitZettaponcelets
    }
}
impl Add<UnitZettaponcelets> for UnitZettaponcelets {
    type Output = UnitZettaponcelets;
    #[inline]
    fn add(self, _: UnitZettaponcelets) -> Self::Output {
        UnitZettaponcelets
    }
}
impl AddAssign<UnitZettaponcelets> for UnitZettaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitZettaponcelets) {}
}
impl Sub<UnitZettaponcelets> for UnitZettaponcelets {
    type Output = UnitZettaponcelets;
    #[inline]
    fn sub(self, _: UnitZettaponcelets) -> Self::Output {
        UnitZettaponcelets
    }
}
impl SubAssign<UnitZettaponcelets> for UnitZettaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitZettaponcelets) {}
}
pub struct UnitZettaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZettaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZettaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZettaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitZettaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZettaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZettaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZettaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitZettaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZettaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZettaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for isize {
    type Output = Quantity<isize, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for usize {
    type Output = Quantity<usize, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
impl Mul<UnitZettaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitZettaponcelets>;
    fn mul(self, _: UnitZettaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZettaponcelets)
    }
}
pub struct UnitExaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaponcelets {
    #[inline]
    fn clone(&self) -> UnitExaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaponcelets {
    #[inline]
    fn eq(&self, other: &UnitExaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitExaponcelets {
    fn default() -> Self {
        UnitExaponcelets
    }
}
impl Add<UnitExaponcelets> for UnitExaponcelets {
    type Output = UnitExaponcelets;
    #[inline]
    fn add(self, _: UnitExaponcelets) -> Self::Output {
        UnitExaponcelets
    }
}
impl AddAssign<UnitExaponcelets> for UnitExaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitExaponcelets) {}
}
impl Sub<UnitExaponcelets> for UnitExaponcelets {
    type Output = UnitExaponcelets;
    #[inline]
    fn sub(self, _: UnitExaponcelets) -> Self::Output {
        UnitExaponcelets
    }
}
impl SubAssign<UnitExaponcelets> for UnitExaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitExaponcelets) {}
}
pub struct UnitExaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitExaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitExaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitExaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitExaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitExaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitExaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitExaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitExaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitExaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitExaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for isize {
    type Output = Quantity<isize, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for usize {
    type Output = Quantity<usize, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
impl Mul<UnitExaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitExaponcelets>;
    fn mul(self, _: UnitExaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitExaponcelets)
    }
}
pub struct UnitPetaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaponcelets {
    #[inline]
    fn clone(&self) -> UnitPetaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaponcelets {
    #[inline]
    fn eq(&self, other: &UnitPetaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPetaponcelets {
    fn default() -> Self {
        UnitPetaponcelets
    }
}
impl Add<UnitPetaponcelets> for UnitPetaponcelets {
    type Output = UnitPetaponcelets;
    #[inline]
    fn add(self, _: UnitPetaponcelets) -> Self::Output {
        UnitPetaponcelets
    }
}
impl AddAssign<UnitPetaponcelets> for UnitPetaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitPetaponcelets) {}
}
impl Sub<UnitPetaponcelets> for UnitPetaponcelets {
    type Output = UnitPetaponcelets;
    #[inline]
    fn sub(self, _: UnitPetaponcelets) -> Self::Output {
        UnitPetaponcelets
    }
}
impl SubAssign<UnitPetaponcelets> for UnitPetaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitPetaponcelets) {}
}
pub struct UnitPetaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPetaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPetaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPetaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitPetaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPetaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPetaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPetaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitPetaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPetaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPetaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for isize {
    type Output = Quantity<isize, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for usize {
    type Output = Quantity<usize, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
impl Mul<UnitPetaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitPetaponcelets>;
    fn mul(self, _: UnitPetaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPetaponcelets)
    }
}
pub struct UnitTeraponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraponcelets {
    #[inline]
    fn clone(&self) -> UnitTeraponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraponcelets {
    #[inline]
    fn eq(&self, other: &UnitTeraponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitTeraponcelets {
    fn default() -> Self {
        UnitTeraponcelets
    }
}
impl Add<UnitTeraponcelets> for UnitTeraponcelets {
    type Output = UnitTeraponcelets;
    #[inline]
    fn add(self, _: UnitTeraponcelets) -> Self::Output {
        UnitTeraponcelets
    }
}
impl AddAssign<UnitTeraponcelets> for UnitTeraponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitTeraponcelets) {}
}
impl Sub<UnitTeraponcelets> for UnitTeraponcelets {
    type Output = UnitTeraponcelets;
    #[inline]
    fn sub(self, _: UnitTeraponcelets) -> Self::Output {
        UnitTeraponcelets
    }
}
impl SubAssign<UnitTeraponcelets> for UnitTeraponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitTeraponcelets) {}
}
pub struct UnitTeraponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitTeraponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitTeraponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitTeraponceletsMul {
    #[inline]
    fn clone(&self) -> UnitTeraponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitTeraponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitTeraponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitTeraponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitTeraponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitTeraponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitTeraponceletsMul> for i8 {
    type Output = Quantity<i8, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for i16 {
    type Output = Quantity<i16, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for i32 {
    type Output = Quantity<i32, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for i64 {
    type Output = Quantity<i64, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for i128 {
    type Output = Quantity<i128, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for isize {
    type Output = Quantity<isize, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for u8 {
    type Output = Quantity<u8, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for u16 {
    type Output = Quantity<u16, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for u32 {
    type Output = Quantity<u32, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for u64 {
    type Output = Quantity<u64, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for u128 {
    type Output = Quantity<u128, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for usize {
    type Output = Quantity<usize, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for f32 {
    type Output = Quantity<f32, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
impl Mul<UnitTeraponceletsMul> for f64 {
    type Output = Quantity<f64, UnitTeraponcelets>;
    fn mul(self, _: UnitTeraponceletsMul) -> Self::Output {
        Quantity::new(self, UnitTeraponcelets)
    }
}
pub struct UnitGigaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaponcelets {
    #[inline]
    fn clone(&self) -> UnitGigaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaponcelets {
    #[inline]
    fn eq(&self, other: &UnitGigaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitGigaponcelets {
    fn default() -> Self {
        UnitGigaponcelets
    }
}
impl Add<UnitGigaponcelets> for UnitGigaponcelets {
    type Output = UnitGigaponcelets;
    #[inline]
    fn add(self, _: UnitGigaponcelets) -> Self::Output {
        UnitGigaponcelets
    }
}
impl AddAssign<UnitGigaponcelets> for UnitGigaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitGigaponcelets) {}
}
impl Sub<UnitGigaponcelets> for UnitGigaponcelets {
    type Output = UnitGigaponcelets;
    #[inline]
    fn sub(self, _: UnitGigaponcelets) -> Self::Output {
        UnitGigaponcelets
    }
}
impl SubAssign<UnitGigaponcelets> for UnitGigaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitGigaponcelets) {}
}
pub struct UnitGigaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitGigaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitGigaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitGigaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitGigaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitGigaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitGigaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitGigaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitGigaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitGigaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitGigaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for isize {
    type Output = Quantity<isize, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for usize {
    type Output = Quantity<usize, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
impl Mul<UnitGigaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitGigaponcelets>;
    fn mul(self, _: UnitGigaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitGigaponcelets)
    }
}
pub struct UnitMegaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaponcelets {
    #[inline]
    fn clone(&self) -> UnitMegaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaponcelets {
    #[inline]
    fn eq(&self, other: &UnitMegaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMegaponcelets {
    fn default() -> Self {
        UnitMegaponcelets
    }
}
impl Add<UnitMegaponcelets> for UnitMegaponcelets {
    type Output = UnitMegaponcelets;
    #[inline]
    fn add(self, _: UnitMegaponcelets) -> Self::Output {
        UnitMegaponcelets
    }
}
impl AddAssign<UnitMegaponcelets> for UnitMegaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitMegaponcelets) {}
}
impl Sub<UnitMegaponcelets> for UnitMegaponcelets {
    type Output = UnitMegaponcelets;
    #[inline]
    fn sub(self, _: UnitMegaponcelets) -> Self::Output {
        UnitMegaponcelets
    }
}
impl SubAssign<UnitMegaponcelets> for UnitMegaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitMegaponcelets) {}
}
pub struct UnitMegaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMegaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMegaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMegaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitMegaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMegaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMegaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMegaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitMegaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMegaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMegaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for isize {
    type Output = Quantity<isize, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for usize {
    type Output = Quantity<usize, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
impl Mul<UnitMegaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitMegaponcelets>;
    fn mul(self, _: UnitMegaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMegaponcelets)
    }
}
pub struct UnitKiloponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloponcelets {
    #[inline]
    fn clone(&self) -> UnitKiloponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloponcelets {
    #[inline]
    fn eq(&self, other: &UnitKiloponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitKiloponcelets {
    fn default() -> Self {
        UnitKiloponcelets
    }
}
impl Add<UnitKiloponcelets> for UnitKiloponcelets {
    type Output = UnitKiloponcelets;
    #[inline]
    fn add(self, _: UnitKiloponcelets) -> Self::Output {
        UnitKiloponcelets
    }
}
impl AddAssign<UnitKiloponcelets> for UnitKiloponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitKiloponcelets) {}
}
impl Sub<UnitKiloponcelets> for UnitKiloponcelets {
    type Output = UnitKiloponcelets;
    #[inline]
    fn sub(self, _: UnitKiloponcelets) -> Self::Output {
        UnitKiloponcelets
    }
}
impl SubAssign<UnitKiloponcelets> for UnitKiloponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitKiloponcelets) {}
}
pub struct UnitKiloponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitKiloponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitKiloponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitKiloponceletsMul {
    #[inline]
    fn clone(&self) -> UnitKiloponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitKiloponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitKiloponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitKiloponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitKiloponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitKiloponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitKiloponceletsMul> for i8 {
    type Output = Quantity<i8, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for i16 {
    type Output = Quantity<i16, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for i32 {
    type Output = Quantity<i32, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for i64 {
    type Output = Quantity<i64, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for i128 {
    type Output = Quantity<i128, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for isize {
    type Output = Quantity<isize, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for u8 {
    type Output = Quantity<u8, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for u16 {
    type Output = Quantity<u16, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for u32 {
    type Output = Quantity<u32, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for u64 {
    type Output = Quantity<u64, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for u128 {
    type Output = Quantity<u128, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for usize {
    type Output = Quantity<usize, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for f32 {
    type Output = Quantity<f32, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
impl Mul<UnitKiloponceletsMul> for f64 {
    type Output = Quantity<f64, UnitKiloponcelets>;
    fn mul(self, _: UnitKiloponceletsMul) -> Self::Output {
        Quantity::new(self, UnitKiloponcelets)
    }
}
pub struct UnitHectoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoponcelets {
    #[inline]
    fn clone(&self) -> UnitHectoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoponcelets {
    #[inline]
    fn eq(&self, other: &UnitHectoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitHectoponcelets {
    fn default() -> Self {
        UnitHectoponcelets
    }
}
impl Add<UnitHectoponcelets> for UnitHectoponcelets {
    type Output = UnitHectoponcelets;
    #[inline]
    fn add(self, _: UnitHectoponcelets) -> Self::Output {
        UnitHectoponcelets
    }
}
impl AddAssign<UnitHectoponcelets> for UnitHectoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitHectoponcelets) {}
}
impl Sub<UnitHectoponcelets> for UnitHectoponcelets {
    type Output = UnitHectoponcelets;
    #[inline]
    fn sub(self, _: UnitHectoponcelets) -> Self::Output {
        UnitHectoponcelets
    }
}
impl SubAssign<UnitHectoponcelets> for UnitHectoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitHectoponcelets) {}
}
pub struct UnitHectoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitHectoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitHectoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitHectoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitHectoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitHectoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitHectoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitHectoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitHectoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitHectoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitHectoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for isize {
    type Output = Quantity<isize, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for usize {
    type Output = Quantity<usize, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
impl Mul<UnitHectoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitHectoponcelets>;
    fn mul(self, _: UnitHectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitHectoponcelets)
    }
}
pub struct UnitDecaponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaponcelets {
    #[inline]
    fn clone(&self) -> UnitDecaponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaponcelets {
    #[inline]
    fn eq(&self, other: &UnitDecaponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDecaponcelets {
    fn default() -> Self {
        UnitDecaponcelets
    }
}
impl Add<UnitDecaponcelets> for UnitDecaponcelets {
    type Output = UnitDecaponcelets;
    #[inline]
    fn add(self, _: UnitDecaponcelets) -> Self::Output {
        UnitDecaponcelets
    }
}
impl AddAssign<UnitDecaponcelets> for UnitDecaponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitDecaponcelets) {}
}
impl Sub<UnitDecaponcelets> for UnitDecaponcelets {
    type Output = UnitDecaponcelets;
    #[inline]
    fn sub(self, _: UnitDecaponcelets) -> Self::Output {
        UnitDecaponcelets
    }
}
impl SubAssign<UnitDecaponcelets> for UnitDecaponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitDecaponcelets) {}
}
pub struct UnitDecaponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDecaponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDecaponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDecaponceletsMul {
    #[inline]
    fn clone(&self) -> UnitDecaponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDecaponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDecaponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDecaponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitDecaponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDecaponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDecaponceletsMul> for i8 {
    type Output = Quantity<i8, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for i16 {
    type Output = Quantity<i16, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for i32 {
    type Output = Quantity<i32, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for i64 {
    type Output = Quantity<i64, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for i128 {
    type Output = Quantity<i128, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for isize {
    type Output = Quantity<isize, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for u8 {
    type Output = Quantity<u8, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for u16 {
    type Output = Quantity<u16, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for u32 {
    type Output = Quantity<u32, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for u64 {
    type Output = Quantity<u64, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for u128 {
    type Output = Quantity<u128, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for usize {
    type Output = Quantity<usize, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for f32 {
    type Output = Quantity<f32, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
impl Mul<UnitDecaponceletsMul> for f64 {
    type Output = Quantity<f64, UnitDecaponcelets>;
    fn mul(self, _: UnitDecaponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDecaponcelets)
    }
}
pub struct UnitDeciponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciponcelets {
    #[inline]
    fn clone(&self) -> UnitDeciponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciponcelets {
    #[inline]
    fn eq(&self, other: &UnitDeciponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitDeciponcelets {
    fn default() -> Self {
        UnitDeciponcelets
    }
}
impl Add<UnitDeciponcelets> for UnitDeciponcelets {
    type Output = UnitDeciponcelets;
    #[inline]
    fn add(self, _: UnitDeciponcelets) -> Self::Output {
        UnitDeciponcelets
    }
}
impl AddAssign<UnitDeciponcelets> for UnitDeciponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitDeciponcelets) {}
}
impl Sub<UnitDeciponcelets> for UnitDeciponcelets {
    type Output = UnitDeciponcelets;
    #[inline]
    fn sub(self, _: UnitDeciponcelets) -> Self::Output {
        UnitDeciponcelets
    }
}
impl SubAssign<UnitDeciponcelets> for UnitDeciponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitDeciponcelets) {}
}
pub struct UnitDeciponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitDeciponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitDeciponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitDeciponceletsMul {
    #[inline]
    fn clone(&self) -> UnitDeciponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitDeciponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitDeciponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitDeciponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitDeciponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitDeciponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitDeciponceletsMul> for i8 {
    type Output = Quantity<i8, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for i16 {
    type Output = Quantity<i16, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for i32 {
    type Output = Quantity<i32, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for i64 {
    type Output = Quantity<i64, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for i128 {
    type Output = Quantity<i128, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for isize {
    type Output = Quantity<isize, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for u8 {
    type Output = Quantity<u8, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for u16 {
    type Output = Quantity<u16, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for u32 {
    type Output = Quantity<u32, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for u64 {
    type Output = Quantity<u64, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for u128 {
    type Output = Quantity<u128, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for usize {
    type Output = Quantity<usize, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for f32 {
    type Output = Quantity<f32, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
impl Mul<UnitDeciponceletsMul> for f64 {
    type Output = Quantity<f64, UnitDeciponcelets>;
    fn mul(self, _: UnitDeciponceletsMul) -> Self::Output {
        Quantity::new(self, UnitDeciponcelets)
    }
}
pub struct UnitCentiponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiponcelets {
    #[inline]
    fn clone(&self) -> UnitCentiponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiponcelets {
    #[inline]
    fn eq(&self, other: &UnitCentiponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitCentiponcelets {
    fn default() -> Self {
        UnitCentiponcelets
    }
}
impl Add<UnitCentiponcelets> for UnitCentiponcelets {
    type Output = UnitCentiponcelets;
    #[inline]
    fn add(self, _: UnitCentiponcelets) -> Self::Output {
        UnitCentiponcelets
    }
}
impl AddAssign<UnitCentiponcelets> for UnitCentiponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitCentiponcelets) {}
}
impl Sub<UnitCentiponcelets> for UnitCentiponcelets {
    type Output = UnitCentiponcelets;
    #[inline]
    fn sub(self, _: UnitCentiponcelets) -> Self::Output {
        UnitCentiponcelets
    }
}
impl SubAssign<UnitCentiponcelets> for UnitCentiponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitCentiponcelets) {}
}
pub struct UnitCentiponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitCentiponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitCentiponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitCentiponceletsMul {
    #[inline]
    fn clone(&self) -> UnitCentiponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitCentiponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitCentiponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitCentiponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitCentiponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitCentiponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitCentiponceletsMul> for i8 {
    type Output = Quantity<i8, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for i16 {
    type Output = Quantity<i16, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for i32 {
    type Output = Quantity<i32, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for i64 {
    type Output = Quantity<i64, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for i128 {
    type Output = Quantity<i128, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for isize {
    type Output = Quantity<isize, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for u8 {
    type Output = Quantity<u8, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for u16 {
    type Output = Quantity<u16, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for u32 {
    type Output = Quantity<u32, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for u64 {
    type Output = Quantity<u64, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for u128 {
    type Output = Quantity<u128, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for usize {
    type Output = Quantity<usize, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for f32 {
    type Output = Quantity<f32, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
impl Mul<UnitCentiponceletsMul> for f64 {
    type Output = Quantity<f64, UnitCentiponcelets>;
    fn mul(self, _: UnitCentiponceletsMul) -> Self::Output {
        Quantity::new(self, UnitCentiponcelets)
    }
}
pub struct UnitMilliponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliponcelets {
    #[inline]
    fn clone(&self) -> UnitMilliponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliponcelets {
    #[inline]
    fn eq(&self, other: &UnitMilliponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMilliponcelets {
    fn default() -> Self {
        UnitMilliponcelets
    }
}
impl Add<UnitMilliponcelets> for UnitMilliponcelets {
    type Output = UnitMilliponcelets;
    #[inline]
    fn add(self, _: UnitMilliponcelets) -> Self::Output {
        UnitMilliponcelets
    }
}
impl AddAssign<UnitMilliponcelets> for UnitMilliponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitMilliponcelets) {}
}
impl Sub<UnitMilliponcelets> for UnitMilliponcelets {
    type Output = UnitMilliponcelets;
    #[inline]
    fn sub(self, _: UnitMilliponcelets) -> Self::Output {
        UnitMilliponcelets
    }
}
impl SubAssign<UnitMilliponcelets> for UnitMilliponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitMilliponcelets) {}
}
pub struct UnitMilliponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMilliponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMilliponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMilliponceletsMul {
    #[inline]
    fn clone(&self) -> UnitMilliponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMilliponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMilliponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMilliponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitMilliponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMilliponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMilliponceletsMul> for i8 {
    type Output = Quantity<i8, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for i16 {
    type Output = Quantity<i16, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for i32 {
    type Output = Quantity<i32, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for i64 {
    type Output = Quantity<i64, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for i128 {
    type Output = Quantity<i128, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for isize {
    type Output = Quantity<isize, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for u8 {
    type Output = Quantity<u8, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for u16 {
    type Output = Quantity<u16, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for u32 {
    type Output = Quantity<u32, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for u64 {
    type Output = Quantity<u64, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for u128 {
    type Output = Quantity<u128, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for usize {
    type Output = Quantity<usize, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for f32 {
    type Output = Quantity<f32, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
impl Mul<UnitMilliponceletsMul> for f64 {
    type Output = Quantity<f64, UnitMilliponcelets>;
    fn mul(self, _: UnitMilliponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMilliponcelets)
    }
}
pub struct UnitMicroponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroponcelets {
    #[inline]
    fn clone(&self) -> UnitMicroponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroponcelets {
    #[inline]
    fn eq(&self, other: &UnitMicroponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitMicroponcelets {
    fn default() -> Self {
        UnitMicroponcelets
    }
}
impl Add<UnitMicroponcelets> for UnitMicroponcelets {
    type Output = UnitMicroponcelets;
    #[inline]
    fn add(self, _: UnitMicroponcelets) -> Self::Output {
        UnitMicroponcelets
    }
}
impl AddAssign<UnitMicroponcelets> for UnitMicroponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitMicroponcelets) {}
}
impl Sub<UnitMicroponcelets> for UnitMicroponcelets {
    type Output = UnitMicroponcelets;
    #[inline]
    fn sub(self, _: UnitMicroponcelets) -> Self::Output {
        UnitMicroponcelets
    }
}
impl SubAssign<UnitMicroponcelets> for UnitMicroponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitMicroponcelets) {}
}
pub struct UnitMicroponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitMicroponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitMicroponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitMicroponceletsMul {
    #[inline]
    fn clone(&self) -> UnitMicroponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitMicroponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitMicroponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitMicroponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitMicroponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitMicroponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitMicroponceletsMul> for i8 {
    type Output = Quantity<i8, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for i16 {
    type Output = Quantity<i16, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for i32 {
    type Output = Quantity<i32, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for i64 {
    type Output = Quantity<i64, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for i128 {
    type Output = Quantity<i128, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for isize {
    type Output = Quantity<isize, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for u8 {
    type Output = Quantity<u8, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for u16 {
    type Output = Quantity<u16, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for u32 {
    type Output = Quantity<u32, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for u64 {
    type Output = Quantity<u64, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for u128 {
    type Output = Quantity<u128, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for usize {
    type Output = Quantity<usize, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for f32 {
    type Output = Quantity<f32, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
impl Mul<UnitMicroponceletsMul> for f64 {
    type Output = Quantity<f64, UnitMicroponcelets>;
    fn mul(self, _: UnitMicroponceletsMul) -> Self::Output {
        Quantity::new(self, UnitMicroponcelets)
    }
}
pub struct UnitNanoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoponcelets {
    #[inline]
    fn clone(&self) -> UnitNanoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoponcelets {
    #[inline]
    fn eq(&self, other: &UnitNanoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitNanoponcelets {
    fn default() -> Self {
        UnitNanoponcelets
    }
}
impl Add<UnitNanoponcelets> for UnitNanoponcelets {
    type Output = UnitNanoponcelets;
    #[inline]
    fn add(self, _: UnitNanoponcelets) -> Self::Output {
        UnitNanoponcelets
    }
}
impl AddAssign<UnitNanoponcelets> for UnitNanoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitNanoponcelets) {}
}
impl Sub<UnitNanoponcelets> for UnitNanoponcelets {
    type Output = UnitNanoponcelets;
    #[inline]
    fn sub(self, _: UnitNanoponcelets) -> Self::Output {
        UnitNanoponcelets
    }
}
impl SubAssign<UnitNanoponcelets> for UnitNanoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitNanoponcelets) {}
}
pub struct UnitNanoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitNanoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitNanoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitNanoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitNanoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitNanoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitNanoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitNanoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitNanoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitNanoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitNanoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for isize {
    type Output = Quantity<isize, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for usize {
    type Output = Quantity<usize, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
impl Mul<UnitNanoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitNanoponcelets>;
    fn mul(self, _: UnitNanoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitNanoponcelets)
    }
}
pub struct UnitPicoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoponcelets {
    #[inline]
    fn clone(&self) -> UnitPicoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoponcelets {
    #[inline]
    fn eq(&self, other: &UnitPicoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitPicoponcelets {
    fn default() -> Self {
        UnitPicoponcelets
    }
}
impl Add<UnitPicoponcelets> for UnitPicoponcelets {
    type Output = UnitPicoponcelets;
    #[inline]
    fn add(self, _: UnitPicoponcelets) -> Self::Output {
        UnitPicoponcelets
    }
}
impl AddAssign<UnitPicoponcelets> for UnitPicoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitPicoponcelets) {}
}
impl Sub<UnitPicoponcelets> for UnitPicoponcelets {
    type Output = UnitPicoponcelets;
    #[inline]
    fn sub(self, _: UnitPicoponcelets) -> Self::Output {
        UnitPicoponcelets
    }
}
impl SubAssign<UnitPicoponcelets> for UnitPicoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitPicoponcelets) {}
}
pub struct UnitPicoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitPicoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitPicoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitPicoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitPicoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitPicoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitPicoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitPicoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitPicoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitPicoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitPicoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for isize {
    type Output = Quantity<isize, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for usize {
    type Output = Quantity<usize, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
impl Mul<UnitPicoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitPicoponcelets>;
    fn mul(self, _: UnitPicoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitPicoponcelets)
    }
}
pub struct UnitFemtoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoponcelets {
    #[inline]
    fn clone(&self) -> UnitFemtoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoponcelets {
    #[inline]
    fn eq(&self, other: &UnitFemtoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitFemtoponcelets {
    fn default() -> Self {
        UnitFemtoponcelets
    }
}
impl Add<UnitFemtoponcelets> for UnitFemtoponcelets {
    type Output = UnitFemtoponcelets;
    #[inline]
    fn add(self, _: UnitFemtoponcelets) -> Self::Output {
        UnitFemtoponcelets
    }
}
impl AddAssign<UnitFemtoponcelets> for UnitFemtoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitFemtoponcelets) {}
}
impl Sub<UnitFemtoponcelets> for UnitFemtoponcelets {
    type Output = UnitFemtoponcelets;
    #[inline]
    fn sub(self, _: UnitFemtoponcelets) -> Self::Output {
        UnitFemtoponcelets
    }
}
impl SubAssign<UnitFemtoponcelets> for UnitFemtoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitFemtoponcelets) {}
}
pub struct UnitFemtoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitFemtoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitFemtoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitFemtoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitFemtoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitFemtoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitFemtoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitFemtoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitFemtoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitFemtoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitFemtoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for isize {
    type Output = Quantity<isize, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for usize {
    type Output = Quantity<usize, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
impl Mul<UnitFemtoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitFemtoponcelets>;
    fn mul(self, _: UnitFemtoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitFemtoponcelets)
    }
}
pub struct UnitAttoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoponcelets {
    #[inline]
    fn clone(&self) -> UnitAttoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoponcelets {
    #[inline]
    fn eq(&self, other: &UnitAttoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitAttoponcelets {
    fn default() -> Self {
        UnitAttoponcelets
    }
}
impl Add<UnitAttoponcelets> for UnitAttoponcelets {
    type Output = UnitAttoponcelets;
    #[inline]
    fn add(self, _: UnitAttoponcelets) -> Self::Output {
        UnitAttoponcelets
    }
}
impl AddAssign<UnitAttoponcelets> for UnitAttoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitAttoponcelets) {}
}
impl Sub<UnitAttoponcelets> for UnitAttoponcelets {
    type Output = UnitAttoponcelets;
    #[inline]
    fn sub(self, _: UnitAttoponcelets) -> Self::Output {
        UnitAttoponcelets
    }
}
impl SubAssign<UnitAttoponcelets> for UnitAttoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitAttoponcelets) {}
}
pub struct UnitAttoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitAttoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitAttoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitAttoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitAttoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitAttoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitAttoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitAttoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitAttoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitAttoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitAttoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for isize {
    type Output = Quantity<isize, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for usize {
    type Output = Quantity<usize, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
impl Mul<UnitAttoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitAttoponcelets>;
    fn mul(self, _: UnitAttoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitAttoponcelets)
    }
}
pub struct UnitZeptoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoponcelets {
    #[inline]
    fn clone(&self) -> UnitZeptoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoponcelets {
    #[inline]
    fn eq(&self, other: &UnitZeptoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitZeptoponcelets {
    fn default() -> Self {
        UnitZeptoponcelets
    }
}
impl Add<UnitZeptoponcelets> for UnitZeptoponcelets {
    type Output = UnitZeptoponcelets;
    #[inline]
    fn add(self, _: UnitZeptoponcelets) -> Self::Output {
        UnitZeptoponcelets
    }
}
impl AddAssign<UnitZeptoponcelets> for UnitZeptoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitZeptoponcelets) {}
}
impl Sub<UnitZeptoponcelets> for UnitZeptoponcelets {
    type Output = UnitZeptoponcelets;
    #[inline]
    fn sub(self, _: UnitZeptoponcelets) -> Self::Output {
        UnitZeptoponcelets
    }
}
impl SubAssign<UnitZeptoponcelets> for UnitZeptoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitZeptoponcelets) {}
}
pub struct UnitZeptoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitZeptoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitZeptoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitZeptoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitZeptoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitZeptoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitZeptoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitZeptoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitZeptoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitZeptoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitZeptoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for isize {
    type Output = Quantity<isize, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for usize {
    type Output = Quantity<usize, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
impl Mul<UnitZeptoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitZeptoponcelets>;
    fn mul(self, _: UnitZeptoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitZeptoponcelets)
    }
}
pub struct UnitYoctoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoponcelets {
    #[inline]
    fn clone(&self) -> UnitYoctoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoponcelets {
    #[inline]
    fn eq(&self, other: &UnitYoctoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitYoctoponcelets {
    fn default() -> Self {
        UnitYoctoponcelets
    }
}
impl Add<UnitYoctoponcelets> for UnitYoctoponcelets {
    type Output = UnitYoctoponcelets;
    #[inline]
    fn add(self, _: UnitYoctoponcelets) -> Self::Output {
        UnitYoctoponcelets
    }
}
impl AddAssign<UnitYoctoponcelets> for UnitYoctoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitYoctoponcelets) {}
}
impl Sub<UnitYoctoponcelets> for UnitYoctoponcelets {
    type Output = UnitYoctoponcelets;
    #[inline]
    fn sub(self, _: UnitYoctoponcelets) -> Self::Output {
        UnitYoctoponcelets
    }
}
impl SubAssign<UnitYoctoponcelets> for UnitYoctoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitYoctoponcelets) {}
}
pub struct UnitYoctoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitYoctoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitYoctoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitYoctoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitYoctoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitYoctoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitYoctoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitYoctoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitYoctoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitYoctoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitYoctoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for isize {
    type Output = Quantity<isize, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for usize {
    type Output = Quantity<usize, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
impl Mul<UnitYoctoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitYoctoponcelets>;
    fn mul(self, _: UnitYoctoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitYoctoponcelets)
    }
}
pub struct UnitRontoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoponcelets {
    #[inline]
    fn clone(&self) -> UnitRontoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoponcelets {
    #[inline]
    fn eq(&self, other: &UnitRontoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitRontoponcelets {
    fn default() -> Self {
        UnitRontoponcelets
    }
}
impl Add<UnitRontoponcelets> for UnitRontoponcelets {
    type Output = UnitRontoponcelets;
    #[inline]
    fn add(self, _: UnitRontoponcelets) -> Self::Output {
        UnitRontoponcelets
    }
}
impl AddAssign<UnitRontoponcelets> for UnitRontoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitRontoponcelets) {}
}
impl Sub<UnitRontoponcelets> for UnitRontoponcelets {
    type Output = UnitRontoponcelets;
    #[inline]
    fn sub(self, _: UnitRontoponcelets) -> Self::Output {
        UnitRontoponcelets
    }
}
impl SubAssign<UnitRontoponcelets> for UnitRontoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitRontoponcelets) {}
}
pub struct UnitRontoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitRontoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitRontoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitRontoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitRontoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitRontoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitRontoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitRontoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitRontoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitRontoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitRontoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for isize {
    type Output = Quantity<isize, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for usize {
    type Output = Quantity<usize, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
impl Mul<UnitRontoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitRontoponcelets>;
    fn mul(self, _: UnitRontoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitRontoponcelets)
    }
}
pub struct UnitQuectoponcelets;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoponcelets {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoponcelets")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoponcelets {
    #[inline]
    fn clone(&self) -> UnitQuectoponcelets {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoponcelets {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoponcelets {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoponcelets {
    #[inline]
    fn eq(&self, other: &UnitQuectoponcelets) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoponcelets {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Default for UnitQuectoponcelets {
    fn default() -> Self {
        UnitQuectoponcelets
    }
}
impl Add<UnitQuectoponcelets> for UnitQuectoponcelets {
    type Output = UnitQuectoponcelets;
    #[inline]
    fn add(self, _: UnitQuectoponcelets) -> Self::Output {
        UnitQuectoponcelets
    }
}
impl AddAssign<UnitQuectoponcelets> for UnitQuectoponcelets {
    #[inline]
    fn add_assign(&mut self, _: UnitQuectoponcelets) {}
}
impl Sub<UnitQuectoponcelets> for UnitQuectoponcelets {
    type Output = UnitQuectoponcelets;
    #[inline]
    fn sub(self, _: UnitQuectoponcelets) -> Self::Output {
        UnitQuectoponcelets
    }
}
impl SubAssign<UnitQuectoponcelets> for UnitQuectoponcelets {
    #[inline]
    fn sub_assign(&mut self, _: UnitQuectoponcelets) {}
}
pub struct UnitQuectoponceletsMul;
#[automatically_derived]
impl ::core::fmt::Debug for UnitQuectoponceletsMul {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "UnitQuectoponceletsMul")
    }
}
#[automatically_derived]
impl ::core::clone::Clone for UnitQuectoponceletsMul {
    #[inline]
    fn clone(&self) -> UnitQuectoponceletsMul {
        *self
    }
}
#[automatically_derived]
impl ::core::marker::Copy for UnitQuectoponceletsMul {}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for UnitQuectoponceletsMul {}
#[automatically_derived]
impl ::core::cmp::PartialEq for UnitQuectoponceletsMul {
    #[inline]
    fn eq(&self, other: &UnitQuectoponceletsMul) -> bool {
        true
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for UnitQuectoponceletsMul {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {}
}
impl Mul<UnitQuectoponceletsMul> for i8 {
    type Output = Quantity<i8, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for i16 {
    type Output = Quantity<i16, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for i32 {
    type Output = Quantity<i32, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for i64 {
    type Output = Quantity<i64, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for i128 {
    type Output = Quantity<i128, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for isize {
    type Output = Quantity<isize, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for u8 {
    type Output = Quantity<u8, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for u16 {
    type Output = Quantity<u16, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for u32 {
    type Output = Quantity<u32, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for u64 {
    type Output = Quantity<u64, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for u128 {
    type Output = Quantity<u128, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for usize {
    type Output = Quantity<usize, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for f32 {
    type Output = Quantity<f32, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
impl Mul<UnitQuectoponceletsMul> for f64 {
    type Output = Quantity<f64, UnitQuectoponcelets>;
    fn mul(self, _: UnitQuectoponceletsMul) -> Self::Output {
        Quantity::new(self, UnitQuectoponcelets)
    }
}
pub type Poncelets<T> = Quantity<T, UnitPoncelets>;
#[allow(non_upper_case_globals)]
pub static Poncelets: UnitPonceletsMul = UnitPonceletsMul;
pub type Quettaponcelets<T> = Quantity<T, UnitQuettaponcelets>;
#[allow(non_upper_case_globals)]
pub static Quettaponcelets: UnitQuettaponceletsMul = UnitQuettaponceletsMul;
pub type Ronnaponcelets<T> = Quantity<T, UnitRonnaponcelets>;
#[allow(non_upper_case_globals)]
pub static Ronnaponcelets: UnitRonnaponceletsMul = UnitRonnaponceletsMul;
pub type Yottaponcelets<T> = Quantity<T, UnitYottaponcelets>;
#[allow(non_upper_case_globals)]
pub static Yottaponcelets: UnitYottaponceletsMul = UnitYottaponceletsMul;
pub type Zettaponcelets<T> = Quantity<T, UnitZettaponcelets>;
#[allow(non_upper_case_globals)]
pub static Zettaponcelets: UnitZettaponceletsMul = UnitZettaponceletsMul;
pub type Exaponcelets<T> = Quantity<T, UnitExaponcelets>;
#[allow(non_upper_case_globals)]
pub static Exaponcelets: UnitExaponceletsMul = UnitExaponceletsMul;
pub type Petaponcelets<T> = Quantity<T, UnitPetaponcelets>;
#[allow(non_upper_case_globals)]
pub static Petaponcelets: UnitPetaponceletsMul = UnitPetaponceletsMul;
pub type Teraponcelets<T> = Quantity<T, UnitTeraponcelets>;
#[allow(non_upper_case_globals)]
pub static Teraponcelets: UnitTeraponceletsMul = UnitTeraponceletsMul;
pub type Gigaponcelets<T> = Quantity<T, UnitGigaponcelets>;
#[allow(non_upper_case_globals)]
pub static Gigaponcelets: UnitGigaponceletsMul = UnitGigaponceletsMul;
pub type Megaponcelets<T> = Quantity<T, UnitMegaponcelets>;
#[allow(non_upper_case_globals)]
pub static Megaponcelets: UnitMegaponceletsMul = UnitMegaponceletsMul;
pub type Kiloponcelets<T> = Quantity<T, UnitKiloponcelets>;
#[allow(non_upper_case_globals)]
pub static Kiloponcelets: UnitKiloponceletsMul = UnitKiloponceletsMul;
pub type Hectoponcelets<T> = Quantity<T, UnitHectoponcelets>;
#[allow(non_upper_case_globals)]
pub static Hectoponcelets: UnitHectoponceletsMul = UnitHectoponceletsMul;
pub type Decaponcelets<T> = Quantity<T, UnitDecaponcelets>;
#[allow(non_upper_case_globals)]
pub static Decaponcelets: UnitDecaponceletsMul = UnitDecaponceletsMul;
pub type Deciponcelets<T> = Quantity<T, UnitDeciponcelets>;
#[allow(non_upper_case_globals)]
pub static Deciponcelets: UnitDeciponceletsMul = UnitDeciponceletsMul;
pub type Centiponcelets<T> = Quantity<T, UnitCentiponcelets>;
#[allow(non_upper_case_globals)]
pub static Centiponcelets: UnitCentiponceletsMul = UnitCentiponceletsMul;
pub type Milliponcelets<T> = Quantity<T, UnitMilliponcelets>;
#[allow(non_upper_case_globals)]
pub static Milliponcelets: UnitMilliponceletsMul = UnitMilliponceletsMul;
pub type Microponcelets<T> = Quantity<T, UnitMicroponcelets>;
#[allow(non_upper_case_globals)]
pub static Microponcelets: UnitMicroponceletsMul = UnitMicroponceletsMul;
pub type Nanoponcelets<T> = Quantity<T, UnitNanoponcelets>;
#[allow(non_upper_case_globals)]
pub static Nanoponcelets: UnitNanoponceletsMul = UnitNanoponceletsMul;
pub type Picoponcelets<T> = Quantity<T, UnitPicoponcelets>;
#[allow(non_upper_case_globals)]
pub static Picoponcelets: UnitPicoponceletsMul = UnitPicoponceletsMul;
pub type Femtoponcelets<T> = Quantity<T, UnitFemtoponcelets>;
#[allow(non_upper_case_globals)]
pub static Femtoponcelets: UnitFemtoponceletsMul = UnitFemtoponceletsMul;
pub type Attoponcelets<T> = Quantity<T, UnitAttoponcelets>;
#[allow(non_upper_case_globals)]
pub static Attoponcelets: UnitAttoponceletsMul = UnitAttoponceletsMul;
pub type Zeptoponcelets<T> = Quantity<T, UnitZeptoponcelets>;
#[allow(non_upper_case_globals)]
pub static Zeptoponcelets: UnitZeptoponceletsMul = UnitZeptoponceletsMul;
pub type Yoctoponcelets<T> = Quantity<T, UnitYoctoponcelets>;
#[allow(non_upper_case_globals)]
pub static Yoctoponcelets: UnitYoctoponceletsMul = UnitYoctoponceletsMul;
pub type Rontoponcelets<T> = Quantity<T, UnitRontoponcelets>;
#[allow(non_upper_case_globals)]
pub static Rontoponcelets: UnitRontoponceletsMul = UnitRontoponceletsMul;
pub type Quectoponcelets<T> = Quantity<T, UnitQuectoponcelets>;
#[allow(non_upper_case_globals)]
pub static Quectoponcelets: UnitQuectoponceletsMul = UnitQuectoponceletsMul;