dunge-shade 0.3.13

use {
    crate::irc::{self, Method, Methods, Swizzle},
    glam::{IVec2, IVec3, IVec4, UVec2, UVec3, UVec4, Vec2, Vec3, Vec4},
    std::marker::PhantomData,
};

macro_rules! sw {
    (x) => {
        naga::SwizzleComponent::X
    };

    (y) => {
        naga::SwizzleComponent::Y
    };

    (z) => {
        naga::SwizzleComponent::Z
    };

    (w) => {
        naga::SwizzleComponent::W
    };

    ($a:ident $b:ident) => {
        Swizzle::N2([sw!($a), sw!($b)], PhantomData, PhantomData)
    };

    ($a:ident $b:ident $c:ident) => {
        Swizzle::N3([sw!($a), sw!($b), sw!($c)], PhantomData, PhantomData)
    };

    ($a:ident $b:ident $c:ident $d:ident) => {
        Swizzle::N4(
            [sw!($a), sw!($b), sw!($c), sw!($d)],
            PhantomData,
            PhantomData,
        )
    };
}

pub struct Vec2Methods<A, B, C> {
    pub xx: Method<A, A>,
    pub xy: Method<A, A>,
    pub yx: Method<A, A>,
    pub yy: Method<A, A>,
    pub xxx: Method<A, B>,
    pub xxy: Method<A, B>,
    pub xyx: Method<A, B>,
    pub xyy: Method<A, B>,
    pub yxx: Method<A, B>,
    pub yxy: Method<A, B>,
    pub yyx: Method<A, B>,
    pub yyy: Method<A, B>,
    pub xxxx: Method<A, C>,
    pub xxxy: Method<A, C>,
    pub xxyx: Method<A, C>,
    pub xxyy: Method<A, C>,
    pub xyxx: Method<A, C>,
    pub xyxy: Method<A, C>,
    pub xyyx: Method<A, C>,
    pub xyyy: Method<A, C>,
    pub yxxx: Method<A, C>,
    pub yxxy: Method<A, C>,
    pub yxyx: Method<A, C>,
    pub yxyy: Method<A, C>,
    pub yyxx: Method<A, C>,
    pub yyxy: Method<A, C>,
    pub yyyx: Method<A, C>,
    pub yyyy: Method<A, C>,
}

const fn vec2_methods<A, B, C>() -> Vec2Methods<A, B, C> {
    Vec2Methods {
        xx: irc::swizzle(sw!(x x)),
        xy: irc::swizzle(sw!(x y)),
        yx: irc::swizzle(sw!(y x)),
        yy: irc::swizzle(sw!(y y)),
        xxx: irc::swizzle(sw!(x x x)),
        xxy: irc::swizzle(sw!(x x y)),
        xyx: irc::swizzle(sw!(x y x)),
        xyy: irc::swizzle(sw!(x y y)),
        yxx: irc::swizzle(sw!(y x x)),
        yxy: irc::swizzle(sw!(y x y)),
        yyx: irc::swizzle(sw!(y y x)),
        yyy: irc::swizzle(sw!(y y y)),
        xxxx: irc::swizzle(sw!(x x x x)),
        xxxy: irc::swizzle(sw!(x x x y)),
        xxyx: irc::swizzle(sw!(x x y x)),
        xxyy: irc::swizzle(sw!(x x y y)),
        xyxx: irc::swizzle(sw!(x y x x)),
        xyxy: irc::swizzle(sw!(x y x y)),
        xyyx: irc::swizzle(sw!(x y y x)),
        xyyy: irc::swizzle(sw!(x y y y)),
        yxxx: irc::swizzle(sw!(y x x x)),
        yxxy: irc::swizzle(sw!(y x x y)),
        yxyx: irc::swizzle(sw!(y x y x)),
        yxyy: irc::swizzle(sw!(y x y y)),
        yyxx: irc::swizzle(sw!(y y x x)),
        yyxy: irc::swizzle(sw!(y y x y)),
        yyyx: irc::swizzle(sw!(y y y x)),
        yyyy: irc::swizzle(sw!(y y y y)),
    }
}

impl Methods for Vec2 {
    type Methods = Vec2Methods<Self, Vec3, Vec4>;
    const METHODS: Vec2Methods<Self, Vec3, Vec4> = vec2_methods();
}

impl Methods for IVec2 {
    type Methods = Vec2Methods<Self, IVec3, IVec4>;
    const METHODS: Vec2Methods<Self, IVec3, IVec4> = vec2_methods();
}

impl Methods for UVec2 {
    type Methods = Vec2Methods<Self, UVec3, UVec4>;
    const METHODS: Vec2Methods<Self, UVec3, UVec4> = vec2_methods();
}

pub struct Vec3Methods<A, B, C> {
    pub xx: Method<B, A>,
    pub xy: Method<B, A>,
    pub xz: Method<B, A>,
    pub yx: Method<B, A>,
    pub yy: Method<B, A>,
    pub yz: Method<B, A>,
    pub zx: Method<B, A>,
    pub zy: Method<B, A>,
    pub zz: Method<B, A>,
    pub xxx: Method<B, B>,
    pub xxy: Method<B, B>,
    pub xxz: Method<B, B>,
    pub xyx: Method<B, B>,
    pub xyy: Method<B, B>,
    pub xyz: Method<B, B>,
    pub xzx: Method<B, B>,
    pub xzy: Method<B, B>,
    pub xzz: Method<B, B>,
    pub yxx: Method<B, B>,
    pub yxy: Method<B, B>,
    pub yxz: Method<B, B>,
    pub yyx: Method<B, B>,
    pub yyy: Method<B, B>,
    pub yyz: Method<B, B>,
    pub yzx: Method<B, B>,
    pub yzy: Method<B, B>,
    pub yzz: Method<B, B>,
    pub zxx: Method<B, B>,
    pub zxy: Method<B, B>,
    pub zxz: Method<B, B>,
    pub zyx: Method<B, B>,
    pub zyy: Method<B, B>,
    pub zyz: Method<B, B>,
    pub zzx: Method<B, B>,
    pub zzy: Method<B, B>,
    pub zzz: Method<B, B>,
    pub xxxx: Method<B, C>,
    pub xxxy: Method<B, C>,
    pub xxxz: Method<B, C>,
    pub xxyx: Method<B, C>,
    pub xxyy: Method<B, C>,
    pub xxyz: Method<B, C>,
    pub xxzx: Method<B, C>,
    pub xxzy: Method<B, C>,
    pub xxzz: Method<B, C>,
    pub xyxx: Method<B, C>,
    pub xyxy: Method<B, C>,
    pub xyxz: Method<B, C>,
    pub xyyx: Method<B, C>,
    pub xyyy: Method<B, C>,
    pub xyyz: Method<B, C>,
    pub xyzx: Method<B, C>,
    pub xyzy: Method<B, C>,
    pub xyzz: Method<B, C>,
    pub xzxx: Method<B, C>,
    pub xzxy: Method<B, C>,
    pub xzxz: Method<B, C>,
    pub xzyx: Method<B, C>,
    pub xzyy: Method<B, C>,
    pub xzyz: Method<B, C>,
    pub xzzx: Method<B, C>,
    pub xzzy: Method<B, C>,
    pub xzzz: Method<B, C>,
    pub yxxx: Method<B, C>,
    pub yxxy: Method<B, C>,
    pub yxxz: Method<B, C>,
    pub yxyx: Method<B, C>,
    pub yxyy: Method<B, C>,
    pub yxyz: Method<B, C>,
    pub yxzx: Method<B, C>,
    pub yxzy: Method<B, C>,
    pub yxzz: Method<B, C>,
    pub yyxx: Method<B, C>,
    pub yyxy: Method<B, C>,
    pub yyxz: Method<B, C>,
    pub yyyx: Method<B, C>,
    pub yyyy: Method<B, C>,
    pub yyyz: Method<B, C>,
    pub yyzx: Method<B, C>,
    pub yyzy: Method<B, C>,
    pub yyzz: Method<B, C>,
    pub yzxx: Method<B, C>,
    pub yzxy: Method<B, C>,
    pub yzxz: Method<B, C>,
    pub yzyx: Method<B, C>,
    pub yzyy: Method<B, C>,
    pub yzyz: Method<B, C>,
    pub yzzx: Method<B, C>,
    pub yzzy: Method<B, C>,
    pub yzzz: Method<B, C>,
    pub zxxx: Method<B, C>,
    pub zxxy: Method<B, C>,
    pub zxxz: Method<B, C>,
    pub zxyx: Method<B, C>,
    pub zxyy: Method<B, C>,
    pub zxyz: Method<B, C>,
    pub zxzx: Method<B, C>,
    pub zxzy: Method<B, C>,
    pub zxzz: Method<B, C>,
    pub zyxx: Method<B, C>,
    pub zyxy: Method<B, C>,
    pub zyxz: Method<B, C>,
    pub zyyx: Method<B, C>,
    pub zyyy: Method<B, C>,
    pub zyyz: Method<B, C>,
    pub zyzx: Method<B, C>,
    pub zyzy: Method<B, C>,
    pub zyzz: Method<B, C>,
    pub zzxx: Method<B, C>,
    pub zzxy: Method<B, C>,
    pub zzxz: Method<B, C>,
    pub zzyx: Method<B, C>,
    pub zzyy: Method<B, C>,
    pub zzyz: Method<B, C>,
    pub zzzx: Method<B, C>,
    pub zzzy: Method<B, C>,
    pub zzzz: Method<B, C>,
}

const fn vec3_methods<A, B, C>() -> Vec3Methods<A, B, C> {
    Vec3Methods {
        xx: irc::swizzle(sw!(x x)),
        xy: irc::swizzle(sw!(x y)),
        xz: irc::swizzle(sw!(x z)),
        yx: irc::swizzle(sw!(y x)),
        yy: irc::swizzle(sw!(y y)),
        yz: irc::swizzle(sw!(y z)),
        zx: irc::swizzle(sw!(z x)),
        zy: irc::swizzle(sw!(z y)),
        zz: irc::swizzle(sw!(z z)),
        xxx: irc::swizzle(sw!(x x x)),
        xxy: irc::swizzle(sw!(x x y)),
        xxz: irc::swizzle(sw!(x x z)),
        xyx: irc::swizzle(sw!(x y x)),
        xyy: irc::swizzle(sw!(x y y)),
        xyz: irc::swizzle(sw!(x y z)),
        xzx: irc::swizzle(sw!(x z x)),
        xzy: irc::swizzle(sw!(x z y)),
        xzz: irc::swizzle(sw!(x z z)),
        yxx: irc::swizzle(sw!(y x x)),
        yxy: irc::swizzle(sw!(y x y)),
        yxz: irc::swizzle(sw!(y x z)),
        yyx: irc::swizzle(sw!(y y x)),
        yyy: irc::swizzle(sw!(y y y)),
        yyz: irc::swizzle(sw!(y y z)),
        yzx: irc::swizzle(sw!(y z x)),
        yzy: irc::swizzle(sw!(y z y)),
        yzz: irc::swizzle(sw!(y z z)),
        zxx: irc::swizzle(sw!(z x x)),
        zxy: irc::swizzle(sw!(z x y)),
        zxz: irc::swizzle(sw!(z x z)),
        zyx: irc::swizzle(sw!(z y x)),
        zyy: irc::swizzle(sw!(z y y)),
        zyz: irc::swizzle(sw!(z y z)),
        zzx: irc::swizzle(sw!(z z x)),
        zzy: irc::swizzle(sw!(z z y)),
        zzz: irc::swizzle(sw!(z z z)),
        xxxx: irc::swizzle(sw!(x x x x)),
        xxxy: irc::swizzle(sw!(x x x y)),
        xxxz: irc::swizzle(sw!(x x x z)),
        xxyx: irc::swizzle(sw!(x x y x)),
        xxyy: irc::swizzle(sw!(x x y y)),
        xxyz: irc::swizzle(sw!(x x y z)),
        xxzx: irc::swizzle(sw!(x x z x)),
        xxzy: irc::swizzle(sw!(x x z y)),
        xxzz: irc::swizzle(sw!(x x z z)),
        xyxx: irc::swizzle(sw!(x y x x)),
        xyxy: irc::swizzle(sw!(x y x y)),
        xyxz: irc::swizzle(sw!(x y x z)),
        xyyx: irc::swizzle(sw!(x y y x)),
        xyyy: irc::swizzle(sw!(x y y y)),
        xyyz: irc::swizzle(sw!(x y y z)),
        xyzx: irc::swizzle(sw!(x y z x)),
        xyzy: irc::swizzle(sw!(x y z y)),
        xyzz: irc::swizzle(sw!(x y z z)),
        xzxx: irc::swizzle(sw!(x z x x)),
        xzxy: irc::swizzle(sw!(x z x y)),
        xzxz: irc::swizzle(sw!(x z x z)),
        xzyx: irc::swizzle(sw!(x z y x)),
        xzyy: irc::swizzle(sw!(x z y y)),
        xzyz: irc::swizzle(sw!(x z y z)),
        xzzx: irc::swizzle(sw!(x z z x)),
        xzzy: irc::swizzle(sw!(x z z y)),
        xzzz: irc::swizzle(sw!(x z z z)),
        yxxx: irc::swizzle(sw!(y x x x)),
        yxxy: irc::swizzle(sw!(y x x y)),
        yxxz: irc::swizzle(sw!(y x x z)),
        yxyx: irc::swizzle(sw!(y x y x)),
        yxyy: irc::swizzle(sw!(y x y y)),
        yxyz: irc::swizzle(sw!(y x y z)),
        yxzx: irc::swizzle(sw!(y x z x)),
        yxzy: irc::swizzle(sw!(y x z y)),
        yxzz: irc::swizzle(sw!(y x z z)),
        yyxx: irc::swizzle(sw!(y y x x)),
        yyxy: irc::swizzle(sw!(y y x y)),
        yyxz: irc::swizzle(sw!(y y x z)),
        yyyx: irc::swizzle(sw!(y y y x)),
        yyyy: irc::swizzle(sw!(y y y y)),
        yyyz: irc::swizzle(sw!(y y y z)),
        yyzx: irc::swizzle(sw!(y y z x)),
        yyzy: irc::swizzle(sw!(y y z y)),
        yyzz: irc::swizzle(sw!(y y z z)),
        yzxx: irc::swizzle(sw!(y z x x)),
        yzxy: irc::swizzle(sw!(y z x y)),
        yzxz: irc::swizzle(sw!(y z x z)),
        yzyx: irc::swizzle(sw!(y z y x)),
        yzyy: irc::swizzle(sw!(y z y y)),
        yzyz: irc::swizzle(sw!(y z y z)),
        yzzx: irc::swizzle(sw!(y z z x)),
        yzzy: irc::swizzle(sw!(y z z y)),
        yzzz: irc::swizzle(sw!(y z z z)),
        zxxx: irc::swizzle(sw!(z x x x)),
        zxxy: irc::swizzle(sw!(z x x y)),
        zxxz: irc::swizzle(sw!(z x x z)),
        zxyx: irc::swizzle(sw!(z x y x)),
        zxyy: irc::swizzle(sw!(z x y y)),
        zxyz: irc::swizzle(sw!(z x y z)),
        zxzx: irc::swizzle(sw!(z x z x)),
        zxzy: irc::swizzle(sw!(z x z y)),
        zxzz: irc::swizzle(sw!(z x z z)),
        zyxx: irc::swizzle(sw!(z y x x)),
        zyxy: irc::swizzle(sw!(z y x y)),
        zyxz: irc::swizzle(sw!(z y x z)),
        zyyx: irc::swizzle(sw!(z y y x)),
        zyyy: irc::swizzle(sw!(z y y y)),
        zyyz: irc::swizzle(sw!(z y y z)),
        zyzx: irc::swizzle(sw!(z y z x)),
        zyzy: irc::swizzle(sw!(z y z y)),
        zyzz: irc::swizzle(sw!(z y z z)),
        zzxx: irc::swizzle(sw!(z z x x)),
        zzxy: irc::swizzle(sw!(z z x y)),
        zzxz: irc::swizzle(sw!(z z x z)),
        zzyx: irc::swizzle(sw!(z z y x)),
        zzyy: irc::swizzle(sw!(z z y y)),
        zzyz: irc::swizzle(sw!(z z y z)),
        zzzx: irc::swizzle(sw!(z z z x)),
        zzzy: irc::swizzle(sw!(z z z y)),
        zzzz: irc::swizzle(sw!(z z z z)),
    }
}

impl Methods for Vec3 {
    type Methods = Vec3Methods<Vec2, Self, Vec4>;
    const METHODS: Vec3Methods<Vec2, Self, Vec4> = vec3_methods();
}

impl Methods for IVec3 {
    type Methods = Vec3Methods<IVec2, Self, IVec4>;
    const METHODS: Vec3Methods<IVec2, Self, IVec4> = vec3_methods();
}

impl Methods for UVec3 {
    type Methods = Vec3Methods<UVec2, Self, UVec4>;
    const METHODS: Vec3Methods<UVec2, Self, UVec4> = vec3_methods();
}

pub struct Vec4Methods<A, B, C> {
    pub xx: Method<C, A>,
    pub xy: Method<C, A>,
    pub xz: Method<C, A>,
    pub xw: Method<C, A>,
    pub yx: Method<C, A>,
    pub yy: Method<C, A>,
    pub yz: Method<C, A>,
    pub yw: Method<C, A>,
    pub zx: Method<C, A>,
    pub zy: Method<C, A>,
    pub zz: Method<C, A>,
    pub zw: Method<C, A>,
    pub wx: Method<C, A>,
    pub wy: Method<C, A>,
    pub wz: Method<C, A>,
    pub ww: Method<C, A>,
    pub xxx: Method<C, B>,
    pub xxy: Method<C, B>,
    pub xxz: Method<C, B>,
    pub xxw: Method<C, B>,
    pub xyx: Method<C, B>,
    pub xyy: Method<C, B>,
    pub xyz: Method<C, B>,
    pub xyw: Method<C, B>,
    pub xzx: Method<C, B>,
    pub xzy: Method<C, B>,
    pub xzz: Method<C, B>,
    pub xzw: Method<C, B>,
    pub xwx: Method<C, B>,
    pub xwy: Method<C, B>,
    pub xwz: Method<C, B>,
    pub xww: Method<C, B>,
    pub yxx: Method<C, B>,
    pub yxy: Method<C, B>,
    pub yxz: Method<C, B>,
    pub yxw: Method<C, B>,
    pub yyx: Method<C, B>,
    pub yyy: Method<C, B>,
    pub yyz: Method<C, B>,
    pub yyw: Method<C, B>,
    pub yzx: Method<C, B>,
    pub yzy: Method<C, B>,
    pub yzz: Method<C, B>,
    pub yzw: Method<C, B>,
    pub ywx: Method<C, B>,
    pub ywy: Method<C, B>,
    pub ywz: Method<C, B>,
    pub yww: Method<C, B>,
    pub zxx: Method<C, B>,
    pub zxy: Method<C, B>,
    pub zxz: Method<C, B>,
    pub zxw: Method<C, B>,
    pub zyx: Method<C, B>,
    pub zyy: Method<C, B>,
    pub zyz: Method<C, B>,
    pub zyw: Method<C, B>,
    pub zzx: Method<C, B>,
    pub zzy: Method<C, B>,
    pub zzz: Method<C, B>,
    pub zzw: Method<C, B>,
    pub zwx: Method<C, B>,
    pub zwy: Method<C, B>,
    pub zwz: Method<C, B>,
    pub zww: Method<C, B>,
    pub wxx: Method<C, B>,
    pub wxy: Method<C, B>,
    pub wxz: Method<C, B>,
    pub wxw: Method<C, B>,
    pub wyx: Method<C, B>,
    pub wyy: Method<C, B>,
    pub wyz: Method<C, B>,
    pub wyw: Method<C, B>,
    pub wzx: Method<C, B>,
    pub wzy: Method<C, B>,
    pub wzz: Method<C, B>,
    pub wzw: Method<C, B>,
    pub wwx: Method<C, B>,
    pub wwy: Method<C, B>,
    pub wwz: Method<C, B>,
    pub www: Method<C, B>,
    pub xxxx: Method<C, C>,
    pub xxxy: Method<C, C>,
    pub xxxz: Method<C, C>,
    pub xxxw: Method<C, C>,
    pub xxyx: Method<C, C>,
    pub xxyy: Method<C, C>,
    pub xxyz: Method<C, C>,
    pub xxyw: Method<C, C>,
    pub xxzx: Method<C, C>,
    pub xxzy: Method<C, C>,
    pub xxzz: Method<C, C>,
    pub xxzw: Method<C, C>,
    pub xxwx: Method<C, C>,
    pub xxwy: Method<C, C>,
    pub xxwz: Method<C, C>,
    pub xxww: Method<C, C>,
    pub xyxx: Method<C, C>,
    pub xyxy: Method<C, C>,
    pub xyxz: Method<C, C>,
    pub xyxw: Method<C, C>,
    pub xyyx: Method<C, C>,
    pub xyyy: Method<C, C>,
    pub xyyz: Method<C, C>,
    pub xyyw: Method<C, C>,
    pub xyzx: Method<C, C>,
    pub xyzy: Method<C, C>,
    pub xyzz: Method<C, C>,
    pub xyzw: Method<C, C>,
    pub xywx: Method<C, C>,
    pub xywy: Method<C, C>,
    pub xywz: Method<C, C>,
    pub xyww: Method<C, C>,
    pub xzxx: Method<C, C>,
    pub xzxy: Method<C, C>,
    pub xzxz: Method<C, C>,
    pub xzxw: Method<C, C>,
    pub xzyx: Method<C, C>,
    pub xzyy: Method<C, C>,
    pub xzyz: Method<C, C>,
    pub xzyw: Method<C, C>,
    pub xzzx: Method<C, C>,
    pub xzzy: Method<C, C>,
    pub xzzz: Method<C, C>,
    pub xzzw: Method<C, C>,
    pub xzwx: Method<C, C>,
    pub xzwy: Method<C, C>,
    pub xzwz: Method<C, C>,
    pub xzww: Method<C, C>,
    pub xwxx: Method<C, C>,
    pub xwxy: Method<C, C>,
    pub xwxz: Method<C, C>,
    pub xwxw: Method<C, C>,
    pub xwyx: Method<C, C>,
    pub xwyy: Method<C, C>,
    pub xwyz: Method<C, C>,
    pub xwyw: Method<C, C>,
    pub xwzx: Method<C, C>,
    pub xwzy: Method<C, C>,
    pub xwzz: Method<C, C>,
    pub xwzw: Method<C, C>,
    pub xwwx: Method<C, C>,
    pub xwwy: Method<C, C>,
    pub xwwz: Method<C, C>,
    pub xwww: Method<C, C>,
    pub yxxx: Method<C, C>,
    pub yxxy: Method<C, C>,
    pub yxxz: Method<C, C>,
    pub yxxw: Method<C, C>,
    pub yxyx: Method<C, C>,
    pub yxyy: Method<C, C>,
    pub yxyz: Method<C, C>,
    pub yxyw: Method<C, C>,
    pub yxzx: Method<C, C>,
    pub yxzy: Method<C, C>,
    pub yxzz: Method<C, C>,
    pub yxzw: Method<C, C>,
    pub yxwx: Method<C, C>,
    pub yxwy: Method<C, C>,
    pub yxwz: Method<C, C>,
    pub yxww: Method<C, C>,
    pub yyxx: Method<C, C>,
    pub yyxy: Method<C, C>,
    pub yyxz: Method<C, C>,
    pub yyxw: Method<C, C>,
    pub yyyx: Method<C, C>,
    pub yyyy: Method<C, C>,
    pub yyyz: Method<C, C>,
    pub yyyw: Method<C, C>,
    pub yyzx: Method<C, C>,
    pub yyzy: Method<C, C>,
    pub yyzz: Method<C, C>,
    pub yyzw: Method<C, C>,
    pub yywx: Method<C, C>,
    pub yywy: Method<C, C>,
    pub yywz: Method<C, C>,
    pub yyww: Method<C, C>,
    pub yzxx: Method<C, C>,
    pub yzxy: Method<C, C>,
    pub yzxz: Method<C, C>,
    pub yzxw: Method<C, C>,
    pub yzyx: Method<C, C>,
    pub yzyy: Method<C, C>,
    pub yzyz: Method<C, C>,
    pub yzyw: Method<C, C>,
    pub yzzx: Method<C, C>,
    pub yzzy: Method<C, C>,
    pub yzzz: Method<C, C>,
    pub yzzw: Method<C, C>,
    pub yzwx: Method<C, C>,
    pub yzwy: Method<C, C>,
    pub yzwz: Method<C, C>,
    pub yzww: Method<C, C>,
    pub ywxx: Method<C, C>,
    pub ywxy: Method<C, C>,
    pub ywxz: Method<C, C>,
    pub ywxw: Method<C, C>,
    pub ywyx: Method<C, C>,
    pub ywyy: Method<C, C>,
    pub ywyz: Method<C, C>,
    pub ywyw: Method<C, C>,
    pub ywzx: Method<C, C>,
    pub ywzy: Method<C, C>,
    pub ywzz: Method<C, C>,
    pub ywzw: Method<C, C>,
    pub ywwx: Method<C, C>,
    pub ywwy: Method<C, C>,
    pub ywwz: Method<C, C>,
    pub ywww: Method<C, C>,
    pub zxxx: Method<C, C>,
    pub zxxy: Method<C, C>,
    pub zxxz: Method<C, C>,
    pub zxxw: Method<C, C>,
    pub zxyx: Method<C, C>,
    pub zxyy: Method<C, C>,
    pub zxyz: Method<C, C>,
    pub zxyw: Method<C, C>,
    pub zxzx: Method<C, C>,
    pub zxzy: Method<C, C>,
    pub zxzz: Method<C, C>,
    pub zxzw: Method<C, C>,
    pub zxwx: Method<C, C>,
    pub zxwy: Method<C, C>,
    pub zxwz: Method<C, C>,
    pub zxww: Method<C, C>,
    pub zyxx: Method<C, C>,
    pub zyxy: Method<C, C>,
    pub zyxz: Method<C, C>,
    pub zyxw: Method<C, C>,
    pub zyyx: Method<C, C>,
    pub zyyy: Method<C, C>,
    pub zyyz: Method<C, C>,
    pub zyyw: Method<C, C>,
    pub zyzx: Method<C, C>,
    pub zyzy: Method<C, C>,
    pub zyzz: Method<C, C>,
    pub zyzw: Method<C, C>,
    pub zywx: Method<C, C>,
    pub zywy: Method<C, C>,
    pub zywz: Method<C, C>,
    pub zyww: Method<C, C>,
    pub zzxx: Method<C, C>,
    pub zzxy: Method<C, C>,
    pub zzxz: Method<C, C>,
    pub zzxw: Method<C, C>,
    pub zzyx: Method<C, C>,
    pub zzyy: Method<C, C>,
    pub zzyz: Method<C, C>,
    pub zzyw: Method<C, C>,
    pub zzzx: Method<C, C>,
    pub zzzy: Method<C, C>,
    pub zzzz: Method<C, C>,
    pub zzzw: Method<C, C>,
    pub zzwx: Method<C, C>,
    pub zzwy: Method<C, C>,
    pub zzwz: Method<C, C>,
    pub zzww: Method<C, C>,
    pub zwxx: Method<C, C>,
    pub zwxy: Method<C, C>,
    pub zwxz: Method<C, C>,
    pub zwxw: Method<C, C>,
    pub zwyx: Method<C, C>,
    pub zwyy: Method<C, C>,
    pub zwyz: Method<C, C>,
    pub zwyw: Method<C, C>,
    pub zwzx: Method<C, C>,
    pub zwzy: Method<C, C>,
    pub zwzz: Method<C, C>,
    pub zwzw: Method<C, C>,
    pub zwwx: Method<C, C>,
    pub zwwy: Method<C, C>,
    pub zwwz: Method<C, C>,
    pub zwww: Method<C, C>,
    pub wxxx: Method<C, C>,
    pub wxxy: Method<C, C>,
    pub wxxz: Method<C, C>,
    pub wxxw: Method<C, C>,
    pub wxyx: Method<C, C>,
    pub wxyy: Method<C, C>,
    pub wxyz: Method<C, C>,
    pub wxyw: Method<C, C>,
    pub wxzx: Method<C, C>,
    pub wxzy: Method<C, C>,
    pub wxzz: Method<C, C>,
    pub wxzw: Method<C, C>,
    pub wxwx: Method<C, C>,
    pub wxwy: Method<C, C>,
    pub wxwz: Method<C, C>,
    pub wxww: Method<C, C>,
    pub wyxx: Method<C, C>,
    pub wyxy: Method<C, C>,
    pub wyxz: Method<C, C>,
    pub wyxw: Method<C, C>,
    pub wyyx: Method<C, C>,
    pub wyyy: Method<C, C>,
    pub wyyz: Method<C, C>,
    pub wyyw: Method<C, C>,
    pub wyzx: Method<C, C>,
    pub wyzy: Method<C, C>,
    pub wyzz: Method<C, C>,
    pub wyzw: Method<C, C>,
    pub wywx: Method<C, C>,
    pub wywy: Method<C, C>,
    pub wywz: Method<C, C>,
    pub wyww: Method<C, C>,
    pub wzxx: Method<C, C>,
    pub wzxy: Method<C, C>,
    pub wzxz: Method<C, C>,
    pub wzxw: Method<C, C>,
    pub wzyx: Method<C, C>,
    pub wzyy: Method<C, C>,
    pub wzyz: Method<C, C>,
    pub wzyw: Method<C, C>,
    pub wzzx: Method<C, C>,
    pub wzzy: Method<C, C>,
    pub wzzz: Method<C, C>,
    pub wzzw: Method<C, C>,
    pub wzwx: Method<C, C>,
    pub wzwy: Method<C, C>,
    pub wzwz: Method<C, C>,
    pub wzww: Method<C, C>,
    pub wwxx: Method<C, C>,
    pub wwxy: Method<C, C>,
    pub wwxz: Method<C, C>,
    pub wwxw: Method<C, C>,
    pub wwyx: Method<C, C>,
    pub wwyy: Method<C, C>,
    pub wwyz: Method<C, C>,
    pub wwyw: Method<C, C>,
    pub wwzx: Method<C, C>,
    pub wwzy: Method<C, C>,
    pub wwzz: Method<C, C>,
    pub wwzw: Method<C, C>,
    pub wwwx: Method<C, C>,
    pub wwwy: Method<C, C>,
    pub wwwz: Method<C, C>,
    pub wwww: Method<C, C>,
}

const fn vec4_methods<A, B, C>() -> Vec4Methods<A, B, C> {
    Vec4Methods {
        xx: irc::swizzle(sw!(x x)),
        xy: irc::swizzle(sw!(x y)),
        xz: irc::swizzle(sw!(x z)),
        xw: irc::swizzle(sw!(x w)),
        yx: irc::swizzle(sw!(y x)),
        yy: irc::swizzle(sw!(y y)),
        yz: irc::swizzle(sw!(y z)),
        yw: irc::swizzle(sw!(y w)),
        zx: irc::swizzle(sw!(z x)),
        zy: irc::swizzle(sw!(z y)),
        zz: irc::swizzle(sw!(z z)),
        zw: irc::swizzle(sw!(z w)),
        wx: irc::swizzle(sw!(w x)),
        wy: irc::swizzle(sw!(w y)),
        wz: irc::swizzle(sw!(w z)),
        ww: irc::swizzle(sw!(w w)),
        xxx: irc::swizzle(sw!(x x x)),
        xxy: irc::swizzle(sw!(x x y)),
        xxz: irc::swizzle(sw!(x x z)),
        xxw: irc::swizzle(sw!(x x w)),
        xyx: irc::swizzle(sw!(x y x)),
        xyy: irc::swizzle(sw!(x y y)),
        xyz: irc::swizzle(sw!(x y z)),
        xyw: irc::swizzle(sw!(x y w)),
        xzx: irc::swizzle(sw!(x z x)),
        xzy: irc::swizzle(sw!(x z y)),
        xzz: irc::swizzle(sw!(x z z)),
        xzw: irc::swizzle(sw!(x z w)),
        xwx: irc::swizzle(sw!(x w x)),
        xwy: irc::swizzle(sw!(x w y)),
        xwz: irc::swizzle(sw!(x w z)),
        xww: irc::swizzle(sw!(x w w)),
        yxx: irc::swizzle(sw!(y x x)),
        yxy: irc::swizzle(sw!(y x y)),
        yxz: irc::swizzle(sw!(y x z)),
        yxw: irc::swizzle(sw!(y x w)),
        yyx: irc::swizzle(sw!(y y x)),
        yyy: irc::swizzle(sw!(y y y)),
        yyz: irc::swizzle(sw!(y y z)),
        yyw: irc::swizzle(sw!(y y w)),
        yzx: irc::swizzle(sw!(y z x)),
        yzy: irc::swizzle(sw!(y z y)),
        yzz: irc::swizzle(sw!(y z z)),
        yzw: irc::swizzle(sw!(y z w)),
        ywx: irc::swizzle(sw!(y w x)),
        ywy: irc::swizzle(sw!(y w y)),
        ywz: irc::swizzle(sw!(y w z)),
        yww: irc::swizzle(sw!(y w w)),
        zxx: irc::swizzle(sw!(z x x)),
        zxy: irc::swizzle(sw!(z x y)),
        zxz: irc::swizzle(sw!(z x z)),
        zxw: irc::swizzle(sw!(z x w)),
        zyx: irc::swizzle(sw!(z y x)),
        zyy: irc::swizzle(sw!(z y y)),
        zyz: irc::swizzle(sw!(z y z)),
        zyw: irc::swizzle(sw!(z y w)),
        zzx: irc::swizzle(sw!(z z x)),
        zzy: irc::swizzle(sw!(z z y)),
        zzz: irc::swizzle(sw!(z z z)),
        zzw: irc::swizzle(sw!(z z w)),
        zwx: irc::swizzle(sw!(z w x)),
        zwy: irc::swizzle(sw!(z w y)),
        zwz: irc::swizzle(sw!(z w z)),
        zww: irc::swizzle(sw!(z w w)),
        wxx: irc::swizzle(sw!(w x x)),
        wxy: irc::swizzle(sw!(w x y)),
        wxz: irc::swizzle(sw!(w x z)),
        wxw: irc::swizzle(sw!(w x w)),
        wyx: irc::swizzle(sw!(w y x)),
        wyy: irc::swizzle(sw!(w y y)),
        wyz: irc::swizzle(sw!(w y z)),
        wyw: irc::swizzle(sw!(w y w)),
        wzx: irc::swizzle(sw!(w z x)),
        wzy: irc::swizzle(sw!(w z y)),
        wzz: irc::swizzle(sw!(w z z)),
        wzw: irc::swizzle(sw!(w z w)),
        wwx: irc::swizzle(sw!(w w x)),
        wwy: irc::swizzle(sw!(w w y)),
        wwz: irc::swizzle(sw!(w w z)),
        www: irc::swizzle(sw!(w w w)),
        xxxx: irc::swizzle(sw!(x x x x)),
        xxxy: irc::swizzle(sw!(x x x y)),
        xxxz: irc::swizzle(sw!(x x x z)),
        xxxw: irc::swizzle(sw!(x x x w)),
        xxyx: irc::swizzle(sw!(x x y x)),
        xxyy: irc::swizzle(sw!(x x y y)),
        xxyz: irc::swizzle(sw!(x x y z)),
        xxyw: irc::swizzle(sw!(x x y w)),
        xxzx: irc::swizzle(sw!(x x z x)),
        xxzy: irc::swizzle(sw!(x x z y)),
        xxzz: irc::swizzle(sw!(x x z z)),
        xxzw: irc::swizzle(sw!(x x z w)),
        xxwx: irc::swizzle(sw!(x x w x)),
        xxwy: irc::swizzle(sw!(x x w y)),
        xxwz: irc::swizzle(sw!(x x w z)),
        xxww: irc::swizzle(sw!(x x w w)),
        xyxx: irc::swizzle(sw!(x y x x)),
        xyxy: irc::swizzle(sw!(x y x y)),
        xyxz: irc::swizzle(sw!(x y x z)),
        xyxw: irc::swizzle(sw!(x y x w)),
        xyyx: irc::swizzle(sw!(x y y x)),
        xyyy: irc::swizzle(sw!(x y y y)),
        xyyz: irc::swizzle(sw!(x y y z)),
        xyyw: irc::swizzle(sw!(x y y w)),
        xyzx: irc::swizzle(sw!(x y z x)),
        xyzy: irc::swizzle(sw!(x y z y)),
        xyzz: irc::swizzle(sw!(x y z z)),
        xyzw: irc::swizzle(sw!(x y z w)),
        xywx: irc::swizzle(sw!(x y w x)),
        xywy: irc::swizzle(sw!(x y w y)),
        xywz: irc::swizzle(sw!(x y w z)),
        xyww: irc::swizzle(sw!(x y w w)),
        xzxx: irc::swizzle(sw!(x z x x)),
        xzxy: irc::swizzle(sw!(x z x y)),
        xzxz: irc::swizzle(sw!(x z x z)),
        xzxw: irc::swizzle(sw!(x z x w)),
        xzyx: irc::swizzle(sw!(x z y x)),
        xzyy: irc::swizzle(sw!(x z y y)),
        xzyz: irc::swizzle(sw!(x z y z)),
        xzyw: irc::swizzle(sw!(x z y w)),
        xzzx: irc::swizzle(sw!(x z z x)),
        xzzy: irc::swizzle(sw!(x z z y)),
        xzzz: irc::swizzle(sw!(x z z z)),
        xzzw: irc::swizzle(sw!(x z z w)),
        xzwx: irc::swizzle(sw!(x z w x)),
        xzwy: irc::swizzle(sw!(x z w y)),
        xzwz: irc::swizzle(sw!(x z w z)),
        xzww: irc::swizzle(sw!(x z w w)),
        xwxx: irc::swizzle(sw!(x w x x)),
        xwxy: irc::swizzle(sw!(x w x y)),
        xwxz: irc::swizzle(sw!(x w x z)),
        xwxw: irc::swizzle(sw!(x w x w)),
        xwyx: irc::swizzle(sw!(x w y x)),
        xwyy: irc::swizzle(sw!(x w y y)),
        xwyz: irc::swizzle(sw!(x w y z)),
        xwyw: irc::swizzle(sw!(x w y w)),
        xwzx: irc::swizzle(sw!(x w z x)),
        xwzy: irc::swizzle(sw!(x w z y)),
        xwzz: irc::swizzle(sw!(x w z z)),
        xwzw: irc::swizzle(sw!(x w z w)),
        xwwx: irc::swizzle(sw!(x w w x)),
        xwwy: irc::swizzle(sw!(x w w y)),
        xwwz: irc::swizzle(sw!(x w w z)),
        xwww: irc::swizzle(sw!(x w w w)),
        yxxx: irc::swizzle(sw!(y x x x)),
        yxxy: irc::swizzle(sw!(y x x y)),
        yxxz: irc::swizzle(sw!(y x x z)),
        yxxw: irc::swizzle(sw!(y x x w)),
        yxyx: irc::swizzle(sw!(y x y x)),
        yxyy: irc::swizzle(sw!(y x y y)),
        yxyz: irc::swizzle(sw!(y x y z)),
        yxyw: irc::swizzle(sw!(y x y w)),
        yxzx: irc::swizzle(sw!(y x z x)),
        yxzy: irc::swizzle(sw!(y x z y)),
        yxzz: irc::swizzle(sw!(y x z z)),
        yxzw: irc::swizzle(sw!(y x z w)),
        yxwx: irc::swizzle(sw!(y x w x)),
        yxwy: irc::swizzle(sw!(y x w y)),
        yxwz: irc::swizzle(sw!(y x w z)),
        yxww: irc::swizzle(sw!(y x w w)),
        yyxx: irc::swizzle(sw!(y y x x)),
        yyxy: irc::swizzle(sw!(y y x y)),
        yyxz: irc::swizzle(sw!(y y x z)),
        yyxw: irc::swizzle(sw!(y y x w)),
        yyyx: irc::swizzle(sw!(y y y x)),
        yyyy: irc::swizzle(sw!(y y y y)),
        yyyz: irc::swizzle(sw!(y y y z)),
        yyyw: irc::swizzle(sw!(y y y w)),
        yyzx: irc::swizzle(sw!(y y z x)),
        yyzy: irc::swizzle(sw!(y y z y)),
        yyzz: irc::swizzle(sw!(y y z z)),
        yyzw: irc::swizzle(sw!(y y z w)),
        yywx: irc::swizzle(sw!(y y w x)),
        yywy: irc::swizzle(sw!(y y w y)),
        yywz: irc::swizzle(sw!(y y w z)),
        yyww: irc::swizzle(sw!(y y w w)),
        yzxx: irc::swizzle(sw!(y z x x)),
        yzxy: irc::swizzle(sw!(y z x y)),
        yzxz: irc::swizzle(sw!(y z x z)),
        yzxw: irc::swizzle(sw!(y z x w)),
        yzyx: irc::swizzle(sw!(y z y x)),
        yzyy: irc::swizzle(sw!(y z y y)),
        yzyz: irc::swizzle(sw!(y z y z)),
        yzyw: irc::swizzle(sw!(y z y w)),
        yzzx: irc::swizzle(sw!(y z z x)),
        yzzy: irc::swizzle(sw!(y z z y)),
        yzzz: irc::swizzle(sw!(y z z z)),
        yzzw: irc::swizzle(sw!(y z z w)),
        yzwx: irc::swizzle(sw!(y z w x)),
        yzwy: irc::swizzle(sw!(y z w y)),
        yzwz: irc::swizzle(sw!(y z w z)),
        yzww: irc::swizzle(sw!(y z w w)),
        ywxx: irc::swizzle(sw!(y w x x)),
        ywxy: irc::swizzle(sw!(y w x y)),
        ywxz: irc::swizzle(sw!(y w x z)),
        ywxw: irc::swizzle(sw!(y w x w)),
        ywyx: irc::swizzle(sw!(y w y x)),
        ywyy: irc::swizzle(sw!(y w y y)),
        ywyz: irc::swizzle(sw!(y w y z)),
        ywyw: irc::swizzle(sw!(y w y w)),
        ywzx: irc::swizzle(sw!(y w z x)),
        ywzy: irc::swizzle(sw!(y w z y)),
        ywzz: irc::swizzle(sw!(y w z z)),
        ywzw: irc::swizzle(sw!(y w z w)),
        ywwx: irc::swizzle(sw!(y w w x)),
        ywwy: irc::swizzle(sw!(y w w y)),
        ywwz: irc::swizzle(sw!(y w w z)),
        ywww: irc::swizzle(sw!(y w w w)),
        zxxx: irc::swizzle(sw!(z x x x)),
        zxxy: irc::swizzle(sw!(z x x y)),
        zxxz: irc::swizzle(sw!(z x x z)),
        zxxw: irc::swizzle(sw!(z x x w)),
        zxyx: irc::swizzle(sw!(z x y x)),
        zxyy: irc::swizzle(sw!(z x y y)),
        zxyz: irc::swizzle(sw!(z x y z)),
        zxyw: irc::swizzle(sw!(z x y w)),
        zxzx: irc::swizzle(sw!(z x z x)),
        zxzy: irc::swizzle(sw!(z x z y)),
        zxzz: irc::swizzle(sw!(z x z z)),
        zxzw: irc::swizzle(sw!(z x z w)),
        zxwx: irc::swizzle(sw!(z x w x)),
        zxwy: irc::swizzle(sw!(z x w y)),
        zxwz: irc::swizzle(sw!(z x w z)),
        zxww: irc::swizzle(sw!(z x w w)),
        zyxx: irc::swizzle(sw!(z y x x)),
        zyxy: irc::swizzle(sw!(z y x y)),
        zyxz: irc::swizzle(sw!(z y x z)),
        zyxw: irc::swizzle(sw!(z y x w)),
        zyyx: irc::swizzle(sw!(z y y x)),
        zyyy: irc::swizzle(sw!(z y y y)),
        zyyz: irc::swizzle(sw!(z y y z)),
        zyyw: irc::swizzle(sw!(z y y w)),
        zyzx: irc::swizzle(sw!(z y z x)),
        zyzy: irc::swizzle(sw!(z y z y)),
        zyzz: irc::swizzle(sw!(z y z z)),
        zyzw: irc::swizzle(sw!(z y z w)),
        zywx: irc::swizzle(sw!(z y w x)),
        zywy: irc::swizzle(sw!(z y w y)),
        zywz: irc::swizzle(sw!(z y w z)),
        zyww: irc::swizzle(sw!(z y w w)),
        zzxx: irc::swizzle(sw!(z z x x)),
        zzxy: irc::swizzle(sw!(z z x y)),
        zzxz: irc::swizzle(sw!(z z x z)),
        zzxw: irc::swizzle(sw!(z z x w)),
        zzyx: irc::swizzle(sw!(z z y x)),
        zzyy: irc::swizzle(sw!(z z y y)),
        zzyz: irc::swizzle(sw!(z z y z)),
        zzyw: irc::swizzle(sw!(z z y w)),
        zzzx: irc::swizzle(sw!(z z z x)),
        zzzy: irc::swizzle(sw!(z z z y)),
        zzzz: irc::swizzle(sw!(z z z z)),
        zzzw: irc::swizzle(sw!(z z z w)),
        zzwx: irc::swizzle(sw!(z z w x)),
        zzwy: irc::swizzle(sw!(z z w y)),
        zzwz: irc::swizzle(sw!(z z w z)),
        zzww: irc::swizzle(sw!(z z w w)),
        zwxx: irc::swizzle(sw!(z w x x)),
        zwxy: irc::swizzle(sw!(z w x y)),
        zwxz: irc::swizzle(sw!(z w x z)),
        zwxw: irc::swizzle(sw!(z w x w)),
        zwyx: irc::swizzle(sw!(z w y x)),
        zwyy: irc::swizzle(sw!(z w y y)),
        zwyz: irc::swizzle(sw!(z w y z)),
        zwyw: irc::swizzle(sw!(z w y w)),
        zwzx: irc::swizzle(sw!(z w z x)),
        zwzy: irc::swizzle(sw!(z w z y)),
        zwzz: irc::swizzle(sw!(z w z z)),
        zwzw: irc::swizzle(sw!(z w z w)),
        zwwx: irc::swizzle(sw!(z w w x)),
        zwwy: irc::swizzle(sw!(z w w y)),
        zwwz: irc::swizzle(sw!(z w w z)),
        zwww: irc::swizzle(sw!(z w w w)),
        wxxx: irc::swizzle(sw!(w x x x)),
        wxxy: irc::swizzle(sw!(w x x y)),
        wxxz: irc::swizzle(sw!(w x x z)),
        wxxw: irc::swizzle(sw!(w x x w)),
        wxyx: irc::swizzle(sw!(w x y x)),
        wxyy: irc::swizzle(sw!(w x y y)),
        wxyz: irc::swizzle(sw!(w x y z)),
        wxyw: irc::swizzle(sw!(w x y w)),
        wxzx: irc::swizzle(sw!(w x z x)),
        wxzy: irc::swizzle(sw!(w x z y)),
        wxzz: irc::swizzle(sw!(w x z z)),
        wxzw: irc::swizzle(sw!(w x z w)),
        wxwx: irc::swizzle(sw!(w x w x)),
        wxwy: irc::swizzle(sw!(w x w y)),
        wxwz: irc::swizzle(sw!(w x w z)),
        wxww: irc::swizzle(sw!(w x w w)),
        wyxx: irc::swizzle(sw!(w y x x)),
        wyxy: irc::swizzle(sw!(w y x y)),
        wyxz: irc::swizzle(sw!(w y x z)),
        wyxw: irc::swizzle(sw!(w y x w)),
        wyyx: irc::swizzle(sw!(w y y x)),
        wyyy: irc::swizzle(sw!(w y y y)),
        wyyz: irc::swizzle(sw!(w y y z)),
        wyyw: irc::swizzle(sw!(w y y w)),
        wyzx: irc::swizzle(sw!(w y z x)),
        wyzy: irc::swizzle(sw!(w y z y)),
        wyzz: irc::swizzle(sw!(w y z z)),
        wyzw: irc::swizzle(sw!(w y z w)),
        wywx: irc::swizzle(sw!(w y w x)),
        wywy: irc::swizzle(sw!(w y w y)),
        wywz: irc::swizzle(sw!(w y w z)),
        wyww: irc::swizzle(sw!(w y w w)),
        wzxx: irc::swizzle(sw!(w z x x)),
        wzxy: irc::swizzle(sw!(w z x y)),
        wzxz: irc::swizzle(sw!(w z x z)),
        wzxw: irc::swizzle(sw!(w z x w)),
        wzyx: irc::swizzle(sw!(w z y x)),
        wzyy: irc::swizzle(sw!(w z y y)),
        wzyz: irc::swizzle(sw!(w z y z)),
        wzyw: irc::swizzle(sw!(w z y w)),
        wzzx: irc::swizzle(sw!(w z z x)),
        wzzy: irc::swizzle(sw!(w z z y)),
        wzzz: irc::swizzle(sw!(w z z z)),
        wzzw: irc::swizzle(sw!(w z z w)),
        wzwx: irc::swizzle(sw!(w z w x)),
        wzwy: irc::swizzle(sw!(w z w y)),
        wzwz: irc::swizzle(sw!(w z w z)),
        wzww: irc::swizzle(sw!(w z w w)),
        wwxx: irc::swizzle(sw!(w w x x)),
        wwxy: irc::swizzle(sw!(w w x y)),
        wwxz: irc::swizzle(sw!(w w x z)),
        wwxw: irc::swizzle(sw!(w w x w)),
        wwyx: irc::swizzle(sw!(w w y x)),
        wwyy: irc::swizzle(sw!(w w y y)),
        wwyz: irc::swizzle(sw!(w w y z)),
        wwyw: irc::swizzle(sw!(w w y w)),
        wwzx: irc::swizzle(sw!(w w z x)),
        wwzy: irc::swizzle(sw!(w w z y)),
        wwzz: irc::swizzle(sw!(w w z z)),
        wwzw: irc::swizzle(sw!(w w z w)),
        wwwx: irc::swizzle(sw!(w w w x)),
        wwwy: irc::swizzle(sw!(w w w y)),
        wwwz: irc::swizzle(sw!(w w w z)),
        wwww: irc::swizzle(sw!(w w w w)),
    }
}

impl Methods for Vec4 {
    type Methods = Vec4Methods<Vec2, Vec3, Self>;
    const METHODS: Vec4Methods<Vec2, Vec3, Self> = vec4_methods();
}

impl Methods for IVec4 {
    type Methods = Vec4Methods<IVec2, IVec3, Self>;
    const METHODS: Vec4Methods<IVec2, IVec3, Self> = vec4_methods();
}

impl Methods for UVec4 {
    type Methods = Vec4Methods<UVec2, UVec3, Self>;
    const METHODS: Vec4Methods<UVec2, UVec3, Self> = vec4_methods();
}