#[rustfmt::skip]
pub mod swizzle {
pub trait TupleSwizzle2<A, B> {
fn x(self) -> A;
fn y(self) -> B;
fn xx(self) -> (A, A);
fn xy(self) -> (A, B);
fn yx(self) -> (B, A);
fn yy(self) -> (B, B);
fn r(self) -> A;
fn g(self) -> B;
fn rr(self) -> (A, A);
fn rg(self) -> (A, B);
fn gr(self) -> (B, A);
fn gg(self) -> (B, B);
}
pub trait TupleSwizzle3<A, B, C> {
fn x(self) -> A;
fn y(self) -> B;
fn z(self) -> C;
fn xx(self) -> (A, A);
fn xy(self) -> (A, B);
fn xz(self) -> (A, C);
fn yx(self) -> (B, A);
fn yy(self) -> (B, B);
fn yz(self) -> (B, C);
fn zx(self) -> (C, A);
fn zy(self) -> (C, B);
fn zz(self) -> (C, C);
fn xxx(self) -> (A, A, A);
fn xxy(self) -> (A, A, B);
fn xxz(self) -> (A, A, C);
fn xyx(self) -> (A, B, A);
fn xyy(self) -> (A, B, B);
fn xyz(self) -> (A, B, C);
fn xzx(self) -> (A, C, A);
fn xzy(self) -> (A, C, B);
fn xzz(self) -> (A, C, C);
fn yxx(self) -> (B, A, A);
fn yxy(self) -> (B, A, B);
fn yxz(self) -> (B, A, C);
fn yyx(self) -> (B, B, A);
fn yyy(self) -> (B, B, B);
fn yyz(self) -> (B, B, C);
fn yzx(self) -> (B, C, A);
fn yzy(self) -> (B, C, B);
fn yzz(self) -> (B, C, C);
fn zxx(self) -> (C, A, A);
fn zxy(self) -> (C, A, B);
fn zxz(self) -> (C, A, C);
fn zyx(self) -> (C, B, A);
fn zyy(self) -> (C, B, B);
fn zyz(self) -> (C, B, C);
fn zzx(self) -> (C, C, A);
fn zzy(self) -> (C, C, B);
fn zzz(self) -> (C, C, C);
fn r(self) -> A;
fn g(self) -> B;
fn b(self) -> C;
fn rr(self) -> (A, A);
fn rg(self) -> (A, B);
fn rb(self) -> (A, C);
fn gr(self) -> (B, A);
fn gg(self) -> (B, B);
fn gb(self) -> (B, C);
fn br(self) -> (C, A);
fn bg(self) -> (C, B);
fn bb(self) -> (C, C);
fn rrr(self) -> (A, A, A);
fn rrg(self) -> (A, A, B);
fn rrb(self) -> (A, A, C);
fn rgr(self) -> (A, B, A);
fn rgg(self) -> (A, B, B);
fn rgb(self) -> (A, B, C);
fn rbr(self) -> (A, C, A);
fn rbg(self) -> (A, C, B);
fn rbb(self) -> (A, C, C);
fn grr(self) -> (B, A, A);
fn grg(self) -> (B, A, B);
fn grb(self) -> (B, A, C);
fn ggr(self) -> (B, B, A);
fn ggg(self) -> (B, B, B);
fn ggb(self) -> (B, B, C);
fn gbr(self) -> (B, C, A);
fn gbg(self) -> (B, C, B);
fn gbb(self) -> (B, C, C);
fn brr(self) -> (C, A, A);
fn brg(self) -> (C, A, B);
fn brb(self) -> (C, A, C);
fn bgr(self) -> (C, B, A);
fn bgg(self) -> (C, B, B);
fn bgb(self) -> (C, B, C);
fn bbr(self) -> (C, C, A);
fn bbg(self) -> (C, C, B);
fn bbb(self) -> (C, C, C);
}
pub trait TupleSwizzle4<A, B, C, D> {
fn x(self) -> A;
fn y(self) -> B;
fn z(self) -> C;
fn w(self) -> D;
fn xx(self) -> (A, A);
fn xy(self) -> (A, B);
fn xz(self) -> (A, C);
fn xw(self) -> (A, D);
fn yx(self) -> (B, A);
fn yy(self) -> (B, B);
fn yz(self) -> (B, C);
fn yw(self) -> (B, D);
fn zx(self) -> (C, A);
fn zy(self) -> (C, B);
fn zz(self) -> (C, C);
fn zw(self) -> (C, D);
fn wx(self) -> (D, A);
fn wy(self) -> (D, B);
fn wz(self) -> (D, C);
fn ww(self) -> (D, D);
fn xxx(self) -> (A, A, A);
fn xxy(self) -> (A, A, B);
fn xxz(self) -> (A, A, C);
fn xxw(self) -> (A, A, D);
fn xyx(self) -> (A, B, A);
fn xyy(self) -> (A, B, B);
fn xyz(self) -> (A, B, C);
fn xyw(self) -> (A, B, D);
fn xzx(self) -> (A, C, A);
fn xzy(self) -> (A, C, B);
fn xzz(self) -> (A, C, C);
fn xzw(self) -> (A, C, D);
fn xwx(self) -> (A, D, A);
fn xwy(self) -> (A, D, B);
fn xwz(self) -> (A, D, C);
fn xww(self) -> (A, D, D);
fn yxx(self) -> (B, A, A);
fn yxy(self) -> (B, A, B);
fn yxz(self) -> (B, A, C);
fn yxw(self) -> (B, A, D);
fn yyx(self) -> (B, B, A);
fn yyy(self) -> (B, B, B);
fn yyz(self) -> (B, B, C);
fn yyw(self) -> (B, B, D);
fn yzx(self) -> (B, C, A);
fn yzy(self) -> (B, C, B);
fn yzz(self) -> (B, C, C);
fn yzw(self) -> (B, C, D);
fn ywx(self) -> (B, D, A);
fn ywy(self) -> (B, D, B);
fn ywz(self) -> (B, D, C);
fn yww(self) -> (B, D, D);
fn zxx(self) -> (C, A, A);
fn zxy(self) -> (C, A, B);
fn zxz(self) -> (C, A, C);
fn zxw(self) -> (C, A, D);
fn zyx(self) -> (C, B, A);
fn zyy(self) -> (C, B, B);
fn zyz(self) -> (C, B, C);
fn zyw(self) -> (C, B, D);
fn zzx(self) -> (C, C, A);
fn zzy(self) -> (C, C, B);
fn zzz(self) -> (C, C, C);
fn zzw(self) -> (C, C, D);
fn zwx(self) -> (C, D, A);
fn zwy(self) -> (C, D, B);
fn zwz(self) -> (C, D, C);
fn zww(self) -> (C, D, D);
fn wxx(self) -> (D, A, A);
fn wxy(self) -> (D, A, B);
fn wxz(self) -> (D, A, C);
fn wxw(self) -> (D, A, D);
fn wyx(self) -> (D, B, A);
fn wyy(self) -> (D, B, B);
fn wyz(self) -> (D, B, C);
fn wyw(self) -> (D, B, D);
fn wzx(self) -> (D, C, A);
fn wzy(self) -> (D, C, B);
fn wzz(self) -> (D, C, C);
fn wzw(self) -> (D, C, D);
fn wwx(self) -> (D, D, A);
fn wwy(self) -> (D, D, B);
fn wwz(self) -> (D, D, C);
fn www(self) -> (D, D, D);
fn xxxx(self) -> (A, A, A, A);
fn xxxy(self) -> (A, A, A, B);
fn xxxz(self) -> (A, A, A, C);
fn xxxw(self) -> (A, A, A, D);
fn xxyx(self) -> (A, A, B, A);
fn xxyy(self) -> (A, A, B, B);
fn xxyz(self) -> (A, A, B, C);
fn xxyw(self) -> (A, A, B, D);
fn xxzx(self) -> (A, A, C, A);
fn xxzy(self) -> (A, A, C, B);
fn xxzz(self) -> (A, A, C, C);
fn xxzw(self) -> (A, A, C, D);
fn xxwx(self) -> (A, A, D, A);
fn xxwy(self) -> (A, A, D, B);
fn xxwz(self) -> (A, A, D, C);
fn xxww(self) -> (A, A, D, D);
fn xyxx(self) -> (A, B, A, A);
fn xyxy(self) -> (A, B, A, B);
fn xyxz(self) -> (A, B, A, C);
fn xyxw(self) -> (A, B, A, D);
fn xyyx(self) -> (A, B, B, A);
fn xyyy(self) -> (A, B, B, B);
fn xyyz(self) -> (A, B, B, C);
fn xyyw(self) -> (A, B, B, D);
fn xyzx(self) -> (A, B, C, A);
fn xyzy(self) -> (A, B, C, B);
fn xyzz(self) -> (A, B, C, C);
fn xyzw(self) -> (A, B, C, D);
fn xywx(self) -> (A, B, D, A);
fn xywy(self) -> (A, B, D, B);
fn xywz(self) -> (A, B, D, C);
fn xyww(self) -> (A, B, D, D);
fn xzxx(self) -> (A, C, A, A);
fn xzxy(self) -> (A, C, A, B);
fn xzxz(self) -> (A, C, A, C);
fn xzxw(self) -> (A, C, A, D);
fn xzyx(self) -> (A, C, B, A);
fn xzyy(self) -> (A, C, B, B);
fn xzyz(self) -> (A, C, B, C);
fn xzyw(self) -> (A, C, B, D);
fn xzzx(self) -> (A, C, C, A);
fn xzzy(self) -> (A, C, C, B);
fn xzzz(self) -> (A, C, C, C);
fn xzzw(self) -> (A, C, C, D);
fn xzwx(self) -> (A, C, D, A);
fn xzwy(self) -> (A, C, D, B);
fn xzwz(self) -> (A, C, D, C);
fn xzww(self) -> (A, C, D, D);
fn xwxx(self) -> (A, D, A, A);
fn xwxy(self) -> (A, D, A, B);
fn xwxz(self) -> (A, D, A, C);
fn xwxw(self) -> (A, D, A, D);
fn xwyx(self) -> (A, D, B, A);
fn xwyy(self) -> (A, D, B, B);
fn xwyz(self) -> (A, D, B, C);
fn xwyw(self) -> (A, D, B, D);
fn xwzx(self) -> (A, D, C, A);
fn xwzy(self) -> (A, D, C, B);
fn xwzz(self) -> (A, D, C, C);
fn xwzw(self) -> (A, D, C, D);
fn xwwx(self) -> (A, D, D, A);
fn xwwy(self) -> (A, D, D, B);
fn xwwz(self) -> (A, D, D, C);
fn xwww(self) -> (A, D, D, D);
fn yxxx(self) -> (B, A, A, A);
fn yxxy(self) -> (B, A, A, B);
fn yxxz(self) -> (B, A, A, C);
fn yxxw(self) -> (B, A, A, D);
fn yxyx(self) -> (B, A, B, A);
fn yxyy(self) -> (B, A, B, B);
fn yxyz(self) -> (B, A, B, C);
fn yxyw(self) -> (B, A, B, D);
fn yxzx(self) -> (B, A, C, A);
fn yxzy(self) -> (B, A, C, B);
fn yxzz(self) -> (B, A, C, C);
fn yxzw(self) -> (B, A, C, D);
fn yxwx(self) -> (B, A, D, A);
fn yxwy(self) -> (B, A, D, B);
fn yxwz(self) -> (B, A, D, C);
fn yxww(self) -> (B, A, D, D);
fn yyxx(self) -> (B, B, A, A);
fn yyxy(self) -> (B, B, A, B);
fn yyxz(self) -> (B, B, A, C);
fn yyxw(self) -> (B, B, A, D);
fn yyyx(self) -> (B, B, B, A);
fn yyyy(self) -> (B, B, B, B);
fn yyyz(self) -> (B, B, B, C);
fn yyyw(self) -> (B, B, B, D);
fn yyzx(self) -> (B, B, C, A);
fn yyzy(self) -> (B, B, C, B);
fn yyzz(self) -> (B, B, C, C);
fn yyzw(self) -> (B, B, C, D);
fn yywx(self) -> (B, B, D, A);
fn yywy(self) -> (B, B, D, B);
fn yywz(self) -> (B, B, D, C);
fn yyww(self) -> (B, B, D, D);
fn yzxx(self) -> (B, C, A, A);
fn yzxy(self) -> (B, C, A, B);
fn yzxz(self) -> (B, C, A, C);
fn yzxw(self) -> (B, C, A, D);
fn yzyx(self) -> (B, C, B, A);
fn yzyy(self) -> (B, C, B, B);
fn yzyz(self) -> (B, C, B, C);
fn yzyw(self) -> (B, C, B, D);
fn yzzx(self) -> (B, C, C, A);
fn yzzy(self) -> (B, C, C, B);
fn yzzz(self) -> (B, C, C, C);
fn yzzw(self) -> (B, C, C, D);
fn yzwx(self) -> (B, C, D, A);
fn yzwy(self) -> (B, C, D, B);
fn yzwz(self) -> (B, C, D, C);
fn yzww(self) -> (B, C, D, D);
fn ywxx(self) -> (B, D, A, A);
fn ywxy(self) -> (B, D, A, B);
fn ywxz(self) -> (B, D, A, C);
fn ywxw(self) -> (B, D, A, D);
fn ywyx(self) -> (B, D, B, A);
fn ywyy(self) -> (B, D, B, B);
fn ywyz(self) -> (B, D, B, C);
fn ywyw(self) -> (B, D, B, D);
fn ywzx(self) -> (B, D, C, A);
fn ywzy(self) -> (B, D, C, B);
fn ywzz(self) -> (B, D, C, C);
fn ywzw(self) -> (B, D, C, D);
fn ywwx(self) -> (B, D, D, A);
fn ywwy(self) -> (B, D, D, B);
fn ywwz(self) -> (B, D, D, C);
fn ywww(self) -> (B, D, D, D);
fn zxxx(self) -> (C, A, A, A);
fn zxxy(self) -> (C, A, A, B);
fn zxxz(self) -> (C, A, A, C);
fn zxxw(self) -> (C, A, A, D);
fn zxyx(self) -> (C, A, B, A);
fn zxyy(self) -> (C, A, B, B);
fn zxyz(self) -> (C, A, B, C);
fn zxyw(self) -> (C, A, B, D);
fn zxzx(self) -> (C, A, C, A);
fn zxzy(self) -> (C, A, C, B);
fn zxzz(self) -> (C, A, C, C);
fn zxzw(self) -> (C, A, C, D);
fn zxwx(self) -> (C, A, D, A);
fn zxwy(self) -> (C, A, D, B);
fn zxwz(self) -> (C, A, D, C);
fn zxww(self) -> (C, A, D, D);
fn zyxx(self) -> (C, B, A, A);
fn zyxy(self) -> (C, B, A, B);
fn zyxz(self) -> (C, B, A, C);
fn zyxw(self) -> (C, B, A, D);
fn zyyx(self) -> (C, B, B, A);
fn zyyy(self) -> (C, B, B, B);
fn zyyz(self) -> (C, B, B, C);
fn zyyw(self) -> (C, B, B, D);
fn zyzx(self) -> (C, B, C, A);
fn zyzy(self) -> (C, B, C, B);
fn zyzz(self) -> (C, B, C, C);
fn zyzw(self) -> (C, B, C, D);
fn zywx(self) -> (C, B, D, A);
fn zywy(self) -> (C, B, D, B);
fn zywz(self) -> (C, B, D, C);
fn zyww(self) -> (C, B, D, D);
fn zzxx(self) -> (C, C, A, A);
fn zzxy(self) -> (C, C, A, B);
fn zzxz(self) -> (C, C, A, C);
fn zzxw(self) -> (C, C, A, D);
fn zzyx(self) -> (C, C, B, A);
fn zzyy(self) -> (C, C, B, B);
fn zzyz(self) -> (C, C, B, C);
fn zzyw(self) -> (C, C, B, D);
fn zzzx(self) -> (C, C, C, A);
fn zzzy(self) -> (C, C, C, B);
fn zzzz(self) -> (C, C, C, C);
fn zzzw(self) -> (C, C, C, D);
fn zzwx(self) -> (C, C, D, A);
fn zzwy(self) -> (C, C, D, B);
fn zzwz(self) -> (C, C, D, C);
fn zzww(self) -> (C, C, D, D);
fn zwxx(self) -> (C, D, A, A);
fn zwxy(self) -> (C, D, A, B);
fn zwxz(self) -> (C, D, A, C);
fn zwxw(self) -> (C, D, A, D);
fn zwyx(self) -> (C, D, B, A);
fn zwyy(self) -> (C, D, B, B);
fn zwyz(self) -> (C, D, B, C);
fn zwyw(self) -> (C, D, B, D);
fn zwzx(self) -> (C, D, C, A);
fn zwzy(self) -> (C, D, C, B);
fn zwzz(self) -> (C, D, C, C);
fn zwzw(self) -> (C, D, C, D);
fn zwwx(self) -> (C, D, D, A);
fn zwwy(self) -> (C, D, D, B);
fn zwwz(self) -> (C, D, D, C);
fn zwww(self) -> (C, D, D, D);
fn wxxx(self) -> (D, A, A, A);
fn wxxy(self) -> (D, A, A, B);
fn wxxz(self) -> (D, A, A, C);
fn wxxw(self) -> (D, A, A, D);
fn wxyx(self) -> (D, A, B, A);
fn wxyy(self) -> (D, A, B, B);
fn wxyz(self) -> (D, A, B, C);
fn wxyw(self) -> (D, A, B, D);
fn wxzx(self) -> (D, A, C, A);
fn wxzy(self) -> (D, A, C, B);
fn wxzz(self) -> (D, A, C, C);
fn wxzw(self) -> (D, A, C, D);
fn wxwx(self) -> (D, A, D, A);
fn wxwy(self) -> (D, A, D, B);
fn wxwz(self) -> (D, A, D, C);
fn wxww(self) -> (D, A, D, D);
fn wyxx(self) -> (D, B, A, A);
fn wyxy(self) -> (D, B, A, B);
fn wyxz(self) -> (D, B, A, C);
fn wyxw(self) -> (D, B, A, D);
fn wyyx(self) -> (D, B, B, A);
fn wyyy(self) -> (D, B, B, B);
fn wyyz(self) -> (D, B, B, C);
fn wyyw(self) -> (D, B, B, D);
fn wyzx(self) -> (D, B, C, A);
fn wyzy(self) -> (D, B, C, B);
fn wyzz(self) -> (D, B, C, C);
fn wyzw(self) -> (D, B, C, D);
fn wywx(self) -> (D, B, D, A);
fn wywy(self) -> (D, B, D, B);
fn wywz(self) -> (D, B, D, C);
fn wyww(self) -> (D, B, D, D);
fn wzxx(self) -> (D, C, A, A);
fn wzxy(self) -> (D, C, A, B);
fn wzxz(self) -> (D, C, A, C);
fn wzxw(self) -> (D, C, A, D);
fn wzyx(self) -> (D, C, B, A);
fn wzyy(self) -> (D, C, B, B);
fn wzyz(self) -> (D, C, B, C);
fn wzyw(self) -> (D, C, B, D);
fn wzzx(self) -> (D, C, C, A);
fn wzzy(self) -> (D, C, C, B);
fn wzzz(self) -> (D, C, C, C);
fn wzzw(self) -> (D, C, C, D);
fn wzwx(self) -> (D, C, D, A);
fn wzwy(self) -> (D, C, D, B);
fn wzwz(self) -> (D, C, D, C);
fn wzww(self) -> (D, C, D, D);
fn wwxx(self) -> (D, D, A, A);
fn wwxy(self) -> (D, D, A, B);
fn wwxz(self) -> (D, D, A, C);
fn wwxw(self) -> (D, D, A, D);
fn wwyx(self) -> (D, D, B, A);
fn wwyy(self) -> (D, D, B, B);
fn wwyz(self) -> (D, D, B, C);
fn wwyw(self) -> (D, D, B, D);
fn wwzx(self) -> (D, D, C, A);
fn wwzy(self) -> (D, D, C, B);
fn wwzz(self) -> (D, D, C, C);
fn wwzw(self) -> (D, D, C, D);
fn wwwx(self) -> (D, D, D, A);
fn wwwy(self) -> (D, D, D, B);
fn wwwz(self) -> (D, D, D, C);
fn wwww(self) -> (D, D, D, D);
fn r(self) -> A;
fn g(self) -> B;
fn b(self) -> C;
fn a(self) -> D;
fn rr(self) -> (A, A);
fn rg(self) -> (A, B);
fn rb(self) -> (A, C);
fn ra(self) -> (A, D);
fn gr(self) -> (B, A);
fn gg(self) -> (B, B);
fn gb(self) -> (B, C);
fn ga(self) -> (B, D);
fn br(self) -> (C, A);
fn bg(self) -> (C, B);
fn bb(self) -> (C, C);
fn ba(self) -> (C, D);
fn ar(self) -> (D, A);
fn ag(self) -> (D, B);
fn ab(self) -> (D, C);
fn aa(self) -> (D, D);
fn rrr(self) -> (A, A, A);
fn rrg(self) -> (A, A, B);
fn rrb(self) -> (A, A, C);
fn rra(self) -> (A, A, D);
fn rgr(self) -> (A, B, A);
fn rgg(self) -> (A, B, B);
fn rgb(self) -> (A, B, C);
fn rga(self) -> (A, B, D);
fn rbr(self) -> (A, C, A);
fn rbg(self) -> (A, C, B);
fn rbb(self) -> (A, C, C);
fn rba(self) -> (A, C, D);
fn rar(self) -> (A, D, A);
fn rag(self) -> (A, D, B);
fn rab(self) -> (A, D, C);
fn raa(self) -> (A, D, D);
fn grr(self) -> (B, A, A);
fn grg(self) -> (B, A, B);
fn grb(self) -> (B, A, C);
fn gra(self) -> (B, A, D);
fn ggr(self) -> (B, B, A);
fn ggg(self) -> (B, B, B);
fn ggb(self) -> (B, B, C);
fn gga(self) -> (B, B, D);
fn gbr(self) -> (B, C, A);
fn gbg(self) -> (B, C, B);
fn gbb(self) -> (B, C, C);
fn gba(self) -> (B, C, D);
fn gar(self) -> (B, D, A);
fn gag(self) -> (B, D, B);
fn gab(self) -> (B, D, C);
fn gaa(self) -> (B, D, D);
fn brr(self) -> (C, A, A);
fn brg(self) -> (C, A, B);
fn brb(self) -> (C, A, C);
fn bra(self) -> (C, A, D);
fn bgr(self) -> (C, B, A);
fn bgg(self) -> (C, B, B);
fn bgb(self) -> (C, B, C);
fn bga(self) -> (C, B, D);
fn bbr(self) -> (C, C, A);
fn bbg(self) -> (C, C, B);
fn bbb(self) -> (C, C, C);
fn bba(self) -> (C, C, D);
fn bar(self) -> (C, D, A);
fn bag(self) -> (C, D, B);
fn bab(self) -> (C, D, C);
fn baa(self) -> (C, D, D);
fn arr(self) -> (D, A, A);
fn arg(self) -> (D, A, B);
fn arb(self) -> (D, A, C);
fn ara(self) -> (D, A, D);
fn agr(self) -> (D, B, A);
fn agg(self) -> (D, B, B);
fn agb(self) -> (D, B, C);
fn aga(self) -> (D, B, D);
fn abr(self) -> (D, C, A);
fn abg(self) -> (D, C, B);
fn abb(self) -> (D, C, C);
fn aba(self) -> (D, C, D);
fn aar(self) -> (D, D, A);
fn aag(self) -> (D, D, B);
fn aab(self) -> (D, D, C);
fn aaa(self) -> (D, D, D);
fn rrrr(self) -> (A, A, A, A);
fn rrrg(self) -> (A, A, A, B);
fn rrrb(self) -> (A, A, A, C);
fn rrra(self) -> (A, A, A, D);
fn rrgr(self) -> (A, A, B, A);
fn rrgg(self) -> (A, A, B, B);
fn rrgb(self) -> (A, A, B, C);
fn rrga(self) -> (A, A, B, D);
fn rrbr(self) -> (A, A, C, A);
fn rrbg(self) -> (A, A, C, B);
fn rrbb(self) -> (A, A, C, C);
fn rrba(self) -> (A, A, C, D);
fn rrar(self) -> (A, A, D, A);
fn rrag(self) -> (A, A, D, B);
fn rrab(self) -> (A, A, D, C);
fn rraa(self) -> (A, A, D, D);
fn rgrr(self) -> (A, B, A, A);
fn rgrg(self) -> (A, B, A, B);
fn rgrb(self) -> (A, B, A, C);
fn rgra(self) -> (A, B, A, D);
fn rggr(self) -> (A, B, B, A);
fn rggg(self) -> (A, B, B, B);
fn rggb(self) -> (A, B, B, C);
fn rgga(self) -> (A, B, B, D);
fn rgbr(self) -> (A, B, C, A);
fn rgbg(self) -> (A, B, C, B);
fn rgbb(self) -> (A, B, C, C);
fn rgba(self) -> (A, B, C, D);
fn rgar(self) -> (A, B, D, A);
fn rgag(self) -> (A, B, D, B);
fn rgab(self) -> (A, B, D, C);
fn rgaa(self) -> (A, B, D, D);
fn rbrr(self) -> (A, C, A, A);
fn rbrg(self) -> (A, C, A, B);
fn rbrb(self) -> (A, C, A, C);
fn rbra(self) -> (A, C, A, D);
fn rbgr(self) -> (A, C, B, A);
fn rbgg(self) -> (A, C, B, B);
fn rbgb(self) -> (A, C, B, C);
fn rbga(self) -> (A, C, B, D);
fn rbbr(self) -> (A, C, C, A);
fn rbbg(self) -> (A, C, C, B);
fn rbbb(self) -> (A, C, C, C);
fn rbba(self) -> (A, C, C, D);
fn rbar(self) -> (A, C, D, A);
fn rbag(self) -> (A, C, D, B);
fn rbab(self) -> (A, C, D, C);
fn rbaa(self) -> (A, C, D, D);
fn rarr(self) -> (A, D, A, A);
fn rarg(self) -> (A, D, A, B);
fn rarb(self) -> (A, D, A, C);
fn rara(self) -> (A, D, A, D);
fn ragr(self) -> (A, D, B, A);
fn ragg(self) -> (A, D, B, B);
fn ragb(self) -> (A, D, B, C);
fn raga(self) -> (A, D, B, D);
fn rabr(self) -> (A, D, C, A);
fn rabg(self) -> (A, D, C, B);
fn rabb(self) -> (A, D, C, C);
fn raba(self) -> (A, D, C, D);
fn raar(self) -> (A, D, D, A);
fn raag(self) -> (A, D, D, B);
fn raab(self) -> (A, D, D, C);
fn raaa(self) -> (A, D, D, D);
fn grrr(self) -> (B, A, A, A);
fn grrg(self) -> (B, A, A, B);
fn grrb(self) -> (B, A, A, C);
fn grra(self) -> (B, A, A, D);
fn grgr(self) -> (B, A, B, A);
fn grgg(self) -> (B, A, B, B);
fn grgb(self) -> (B, A, B, C);
fn grga(self) -> (B, A, B, D);
fn grbr(self) -> (B, A, C, A);
fn grbg(self) -> (B, A, C, B);
fn grbb(self) -> (B, A, C, C);
fn grba(self) -> (B, A, C, D);
fn grar(self) -> (B, A, D, A);
fn grag(self) -> (B, A, D, B);
fn grab(self) -> (B, A, D, C);
fn graa(self) -> (B, A, D, D);
fn ggrr(self) -> (B, B, A, A);
fn ggrg(self) -> (B, B, A, B);
fn ggrb(self) -> (B, B, A, C);
fn ggra(self) -> (B, B, A, D);
fn gggr(self) -> (B, B, B, A);
fn gggg(self) -> (B, B, B, B);
fn gggb(self) -> (B, B, B, C);
fn ggga(self) -> (B, B, B, D);
fn ggbr(self) -> (B, B, C, A);
fn ggbg(self) -> (B, B, C, B);
fn ggbb(self) -> (B, B, C, C);
fn ggba(self) -> (B, B, C, D);
fn ggar(self) -> (B, B, D, A);
fn ggag(self) -> (B, B, D, B);
fn ggab(self) -> (B, B, D, C);
fn ggaa(self) -> (B, B, D, D);
fn gbrr(self) -> (B, C, A, A);
fn gbrg(self) -> (B, C, A, B);
fn gbrb(self) -> (B, C, A, C);
fn gbra(self) -> (B, C, A, D);
fn gbgr(self) -> (B, C, B, A);
fn gbgg(self) -> (B, C, B, B);
fn gbgb(self) -> (B, C, B, C);
fn gbga(self) -> (B, C, B, D);
fn gbbr(self) -> (B, C, C, A);
fn gbbg(self) -> (B, C, C, B);
fn gbbb(self) -> (B, C, C, C);
fn gbba(self) -> (B, C, C, D);
fn gbar(self) -> (B, C, D, A);
fn gbag(self) -> (B, C, D, B);
fn gbab(self) -> (B, C, D, C);
fn gbaa(self) -> (B, C, D, D);
fn garr(self) -> (B, D, A, A);
fn garg(self) -> (B, D, A, B);
fn garb(self) -> (B, D, A, C);
fn gara(self) -> (B, D, A, D);
fn gagr(self) -> (B, D, B, A);
fn gagg(self) -> (B, D, B, B);
fn gagb(self) -> (B, D, B, C);
fn gaga(self) -> (B, D, B, D);
fn gabr(self) -> (B, D, C, A);
fn gabg(self) -> (B, D, C, B);
fn gabb(self) -> (B, D, C, C);
fn gaba(self) -> (B, D, C, D);
fn gaar(self) -> (B, D, D, A);
fn gaag(self) -> (B, D, D, B);
fn gaab(self) -> (B, D, D, C);
fn gaaa(self) -> (B, D, D, D);
fn brrr(self) -> (C, A, A, A);
fn brrg(self) -> (C, A, A, B);
fn brrb(self) -> (C, A, A, C);
fn brra(self) -> (C, A, A, D);
fn brgr(self) -> (C, A, B, A);
fn brgg(self) -> (C, A, B, B);
fn brgb(self) -> (C, A, B, C);
fn brga(self) -> (C, A, B, D);
fn brbr(self) -> (C, A, C, A);
fn brbg(self) -> (C, A, C, B);
fn brbb(self) -> (C, A, C, C);
fn brba(self) -> (C, A, C, D);
fn brar(self) -> (C, A, D, A);
fn brag(self) -> (C, A, D, B);
fn brab(self) -> (C, A, D, C);
fn braa(self) -> (C, A, D, D);
fn bgrr(self) -> (C, B, A, A);
fn bgrg(self) -> (C, B, A, B);
fn bgrb(self) -> (C, B, A, C);
fn bgra(self) -> (C, B, A, D);
fn bggr(self) -> (C, B, B, A);
fn bggg(self) -> (C, B, B, B);
fn bggb(self) -> (C, B, B, C);
fn bgga(self) -> (C, B, B, D);
fn bgbr(self) -> (C, B, C, A);
fn bgbg(self) -> (C, B, C, B);
fn bgbb(self) -> (C, B, C, C);
fn bgba(self) -> (C, B, C, D);
fn bgar(self) -> (C, B, D, A);
fn bgag(self) -> (C, B, D, B);
fn bgab(self) -> (C, B, D, C);
fn bgaa(self) -> (C, B, D, D);
fn bbrr(self) -> (C, C, A, A);
fn bbrg(self) -> (C, C, A, B);
fn bbrb(self) -> (C, C, A, C);
fn bbra(self) -> (C, C, A, D);
fn bbgr(self) -> (C, C, B, A);
fn bbgg(self) -> (C, C, B, B);
fn bbgb(self) -> (C, C, B, C);
fn bbga(self) -> (C, C, B, D);
fn bbbr(self) -> (C, C, C, A);
fn bbbg(self) -> (C, C, C, B);
fn bbbb(self) -> (C, C, C, C);
fn bbba(self) -> (C, C, C, D);
fn bbar(self) -> (C, C, D, A);
fn bbag(self) -> (C, C, D, B);
fn bbab(self) -> (C, C, D, C);
fn bbaa(self) -> (C, C, D, D);
fn barr(self) -> (C, D, A, A);
fn barg(self) -> (C, D, A, B);
fn barb(self) -> (C, D, A, C);
fn bara(self) -> (C, D, A, D);
fn bagr(self) -> (C, D, B, A);
fn bagg(self) -> (C, D, B, B);
fn bagb(self) -> (C, D, B, C);
fn baga(self) -> (C, D, B, D);
fn babr(self) -> (C, D, C, A);
fn babg(self) -> (C, D, C, B);
fn babb(self) -> (C, D, C, C);
fn baba(self) -> (C, D, C, D);
fn baar(self) -> (C, D, D, A);
fn baag(self) -> (C, D, D, B);
fn baab(self) -> (C, D, D, C);
fn baaa(self) -> (C, D, D, D);
fn arrr(self) -> (D, A, A, A);
fn arrg(self) -> (D, A, A, B);
fn arrb(self) -> (D, A, A, C);
fn arra(self) -> (D, A, A, D);
fn argr(self) -> (D, A, B, A);
fn argg(self) -> (D, A, B, B);
fn argb(self) -> (D, A, B, C);
fn arga(self) -> (D, A, B, D);
fn arbr(self) -> (D, A, C, A);
fn arbg(self) -> (D, A, C, B);
fn arbb(self) -> (D, A, C, C);
fn arba(self) -> (D, A, C, D);
fn arar(self) -> (D, A, D, A);
fn arag(self) -> (D, A, D, B);
fn arab(self) -> (D, A, D, C);
fn araa(self) -> (D, A, D, D);
fn agrr(self) -> (D, B, A, A);
fn agrg(self) -> (D, B, A, B);
fn agrb(self) -> (D, B, A, C);
fn agra(self) -> (D, B, A, D);
fn aggr(self) -> (D, B, B, A);
fn aggg(self) -> (D, B, B, B);
fn aggb(self) -> (D, B, B, C);
fn agga(self) -> (D, B, B, D);
fn agbr(self) -> (D, B, C, A);
fn agbg(self) -> (D, B, C, B);
fn agbb(self) -> (D, B, C, C);
fn agba(self) -> (D, B, C, D);
fn agar(self) -> (D, B, D, A);
fn agag(self) -> (D, B, D, B);
fn agab(self) -> (D, B, D, C);
fn agaa(self) -> (D, B, D, D);
fn abrr(self) -> (D, C, A, A);
fn abrg(self) -> (D, C, A, B);
fn abrb(self) -> (D, C, A, C);
fn abra(self) -> (D, C, A, D);
fn abgr(self) -> (D, C, B, A);
fn abgg(self) -> (D, C, B, B);
fn abgb(self) -> (D, C, B, C);
fn abga(self) -> (D, C, B, D);
fn abbr(self) -> (D, C, C, A);
fn abbg(self) -> (D, C, C, B);
fn abbb(self) -> (D, C, C, C);
fn abba(self) -> (D, C, C, D);
fn abar(self) -> (D, C, D, A);
fn abag(self) -> (D, C, D, B);
fn abab(self) -> (D, C, D, C);
fn abaa(self) -> (D, C, D, D);
fn aarr(self) -> (D, D, A, A);
fn aarg(self) -> (D, D, A, B);
fn aarb(self) -> (D, D, A, C);
fn aara(self) -> (D, D, A, D);
fn aagr(self) -> (D, D, B, A);
fn aagg(self) -> (D, D, B, B);
fn aagb(self) -> (D, D, B, C);
fn aaga(self) -> (D, D, B, D);
fn aabr(self) -> (D, D, C, A);
fn aabg(self) -> (D, D, C, B);
fn aabb(self) -> (D, D, C, C);
fn aaba(self) -> (D, D, C, D);
fn aaar(self) -> (D, D, D, A);
fn aaag(self) -> (D, D, D, B);
fn aaab(self) -> (D, D, D, C);
fn aaaa(self) -> (D, D, D, D);
}
impl<A: Copy, B: Copy> TupleSwizzle2<A, B> for (A, B) {
fn x(self) -> A { self.0 }
fn y(self) -> B { self.1 }
fn xx(self) -> (A, A) { (self.0, self.0) }
fn xy(self) -> (A, B) { (self.0, self.1) }
fn yx(self) -> (B, A) { (self.1, self.0) }
fn yy(self) -> (B, B) { (self.1, self.1) }
fn r(self) -> A { self.0 }
fn g(self) -> B { self.1 }
fn rr(self) -> (A, A) { (self.0, self.0) }
fn rg(self) -> (A, B) { (self.0, self.1) }
fn gr(self) -> (B, A) { (self.1, self.0) }
fn gg(self) -> (B, B) { (self.1, self.1) }
}
impl<A: Copy, B: Copy, C: Copy> TupleSwizzle3<A, B, C> for (A, B, C) {
fn x(self) -> A { self.0 }
fn y(self) -> B { self.1 }
fn z(self) -> C { self.2 }
fn xx(self) -> (A, A){ (self.0, self.0) }
fn xy(self) -> (A, B){ (self.0, self.1) }
fn xz(self) -> (A, C){ (self.0, self.2) }
fn yx(self) -> (B, A){ (self.1, self.0) }
fn yy(self) -> (B, B){ (self.1, self.1) }
fn yz(self) -> (B, C){ (self.1, self.2) }
fn zx(self) -> (C, A){ (self.2, self.0) }
fn zy(self) -> (C, B){ (self.2, self.1) }
fn zz(self) -> (C, C){ (self.2, self.2) }
fn xxx(self) -> (A, A, A) { (self.0, self.0, self.0) }
fn xxy(self) -> (A, A, B) { (self.0, self.0, self.1) }
fn xxz(self) -> (A, A, C) { (self.0, self.0, self.2) }
fn xyx(self) -> (A, B, A) { (self.0, self.1, self.0) }
fn xyy(self) -> (A, B, B) { (self.0, self.1, self.1) }
fn xyz(self) -> (A, B, C) { (self.0, self.1, self.2) }
fn xzx(self) -> (A, C, A) { (self.0, self.2, self.0) }
fn xzy(self) -> (A, C, B) { (self.0, self.2, self.1) }
fn xzz(self) -> (A, C, C) { (self.0, self.2, self.2) }
fn yxx(self) -> (B, A, A) { (self.1, self.0, self.0) }
fn yxy(self) -> (B, A, B) { (self.1, self.0, self.1) }
fn yxz(self) -> (B, A, C) { (self.1, self.0, self.2) }
fn yyx(self) -> (B, B, A) { (self.1, self.1, self.0) }
fn yyy(self) -> (B, B, B) { (self.1, self.1, self.1) }
fn yyz(self) -> (B, B, C) { (self.1, self.1, self.2) }
fn yzx(self) -> (B, C, A) { (self.1, self.2, self.0) }
fn yzy(self) -> (B, C, B) { (self.1, self.2, self.1) }
fn yzz(self) -> (B, C, C) { (self.1, self.2, self.2) }
fn zxx(self) -> (C, A, A) { (self.2, self.0, self.0) }
fn zxy(self) -> (C, A, B) { (self.2, self.0, self.1) }
fn zxz(self) -> (C, A, C) { (self.2, self.0, self.2) }
fn zyx(self) -> (C, B, A) { (self.2, self.1, self.0) }
fn zyy(self) -> (C, B, B) { (self.2, self.1, self.1) }
fn zyz(self) -> (C, B, C) { (self.2, self.1, self.2) }
fn zzx(self) -> (C, C, A) { (self.2, self.2, self.0) }
fn zzy(self) -> (C, C, B) { (self.2, self.2, self.1) }
fn zzz(self) -> (C, C, C) { (self.2, self.2, self.2) }
fn r(self) -> A { self.0 }
fn g(self) -> B { self.1 }
fn b(self) -> C { self.2 }
fn rr(self) -> (A, A){ (self.0, self.0) }
fn rg(self) -> (A, B){ (self.0, self.1) }
fn rb(self) -> (A, C){ (self.0, self.2) }
fn gr(self) -> (B, A){ (self.1, self.0) }
fn gg(self) -> (B, B){ (self.1, self.1) }
fn gb(self) -> (B, C){ (self.1, self.2) }
fn br(self) -> (C, A){ (self.2, self.0) }
fn bg(self) -> (C, B){ (self.2, self.1) }
fn bb(self) -> (C, C){ (self.2, self.2) }
fn rrr(self) -> (A, A, A) { (self.0, self.0, self.0) }
fn rrg(self) -> (A, A, B) { (self.0, self.0, self.1) }
fn rrb(self) -> (A, A, C) { (self.0, self.0, self.2) }
fn rgr(self) -> (A, B, A) { (self.0, self.1, self.0) }
fn rgg(self) -> (A, B, B) { (self.0, self.1, self.1) }
fn rgb(self) -> (A, B, C) { (self.0, self.1, self.2) }
fn rbr(self) -> (A, C, A) { (self.0, self.2, self.0) }
fn rbg(self) -> (A, C, B) { (self.0, self.2, self.1) }
fn rbb(self) -> (A, C, C) { (self.0, self.2, self.2) }
fn grr(self) -> (B, A, A) { (self.1, self.0, self.0) }
fn grg(self) -> (B, A, B) { (self.1, self.0, self.1) }
fn grb(self) -> (B, A, C) { (self.1, self.0, self.2) }
fn ggr(self) -> (B, B, A) { (self.1, self.1, self.0) }
fn ggg(self) -> (B, B, B) { (self.1, self.1, self.1) }
fn ggb(self) -> (B, B, C) { (self.1, self.1, self.2) }
fn gbr(self) -> (B, C, A) { (self.1, self.2, self.0) }
fn gbg(self) -> (B, C, B) { (self.1, self.2, self.1) }
fn gbb(self) -> (B, C, C) { (self.1, self.2, self.2) }
fn brr(self) -> (C, A, A) { (self.2, self.0, self.0) }
fn brg(self) -> (C, A, B) { (self.2, self.0, self.1) }
fn brb(self) -> (C, A, C) { (self.2, self.0, self.2) }
fn bgr(self) -> (C, B, A) { (self.2, self.1, self.0) }
fn bgg(self) -> (C, B, B) { (self.2, self.1, self.1) }
fn bgb(self) -> (C, B, C) { (self.2, self.1, self.2) }
fn bbr(self) -> (C, C, A) { (self.2, self.2, self.0) }
fn bbg(self) -> (C, C, B) { (self.2, self.2, self.1) }
fn bbb(self) -> (C, C, C) { (self.2, self.2, self.2) }
}
impl<A: Copy, B: Copy, C: Copy, D: Copy> TupleSwizzle4<A, B, C, D> for (A, B, C, D) {
fn x(self) -> A { self.0 }
fn y(self) -> B { self.1 }
fn z(self) -> C { self.2 }
fn w(self) -> D { self.3 }
fn xx(self) -> (A, A) { (self.0, self.0) }
fn xy(self) -> (A, B) { (self.0, self.1) }
fn xz(self) -> (A, C) { (self.0, self.2) }
fn xw(self) -> (A, D) { (self.0, self.3) }
fn yx(self) -> (B, A) { (self.1, self.0) }
fn yy(self) -> (B, B) { (self.1, self.1) }
fn yz(self) -> (B, C) { (self.1, self.2) }
fn yw(self) -> (B, D) { (self.1, self.3) }
fn zx(self) -> (C, A) { (self.2, self.0) }
fn zy(self) -> (C, B) { (self.2, self.1) }
fn zz(self) -> (C, C) { (self.2, self.2) }
fn zw(self) -> (C, D) { (self.2, self.3) }
fn wx(self) -> (D, A) { (self.3, self.0) }
fn wy(self) -> (D, B) { (self.3, self.1) }
fn wz(self) -> (D, C) { (self.3, self.2) }
fn ww(self) -> (D, D) { (self.3, self.3) }
fn xxx(self) -> (A, A, A) { (self.0, self.0, self.0) }
fn xxy(self) -> (A, A, B) { (self.0, self.0, self.1) }
fn xxz(self) -> (A, A, C) { (self.0, self.0, self.2) }
fn xxw(self) -> (A, A, D) { (self.0, self.0, self.3) }
fn xyx(self) -> (A, B, A) { (self.0, self.1, self.0) }
fn xyy(self) -> (A, B, B) { (self.0, self.1, self.1) }
fn xyz(self) -> (A, B, C) { (self.0, self.1, self.2) }
fn xyw(self) -> (A, B, D) { (self.0, self.1, self.3) }
fn xzx(self) -> (A, C, A) { (self.0, self.2, self.0) }
fn xzy(self) -> (A, C, B) { (self.0, self.2, self.1) }
fn xzz(self) -> (A, C, C) { (self.0, self.2, self.2) }
fn xzw(self) -> (A, C, D) { (self.0, self.2, self.3) }
fn xwx(self) -> (A, D, A) { (self.0, self.3, self.0) }
fn xwy(self) -> (A, D, B) { (self.0, self.3, self.1) }
fn xwz(self) -> (A, D, C) { (self.0, self.3, self.2) }
fn xww(self) -> (A, D, D) { (self.0, self.3, self.3) }
fn yxx(self) -> (B, A, A) { (self.1, self.0, self.0) }
fn yxy(self) -> (B, A, B) { (self.1, self.0, self.1) }
fn yxz(self) -> (B, A, C) { (self.1, self.0, self.2) }
fn yxw(self) -> (B, A, D) { (self.1, self.0, self.3) }
fn yyx(self) -> (B, B, A) { (self.1, self.1, self.0) }
fn yyy(self) -> (B, B, B) { (self.1, self.1, self.1) }
fn yyz(self) -> (B, B, C) { (self.1, self.1, self.2) }
fn yyw(self) -> (B, B, D) { (self.1, self.1, self.3) }
fn yzx(self) -> (B, C, A) { (self.1, self.2, self.0) }
fn yzy(self) -> (B, C, B) { (self.1, self.2, self.1) }
fn yzz(self) -> (B, C, C) { (self.1, self.2, self.2) }
fn yzw(self) -> (B, C, D) { (self.1, self.2, self.3) }
fn ywx(self) -> (B, D, A) { (self.1, self.3, self.0) }
fn ywy(self) -> (B, D, B) { (self.1, self.3, self.1) }
fn ywz(self) -> (B, D, C) { (self.1, self.3, self.2) }
fn yww(self) -> (B, D, D) { (self.1, self.3, self.3) }
fn zxx(self) -> (C, A, A) { (self.2, self.0, self.0) }
fn zxy(self) -> (C, A, B) { (self.2, self.0, self.1) }
fn zxz(self) -> (C, A, C) { (self.2, self.0, self.2) }
fn zxw(self) -> (C, A, D) { (self.2, self.0, self.3) }
fn zyx(self) -> (C, B, A) { (self.2, self.1, self.0) }
fn zyy(self) -> (C, B, B) { (self.2, self.1, self.1) }
fn zyz(self) -> (C, B, C) { (self.2, self.1, self.2) }
fn zyw(self) -> (C, B, D) { (self.2, self.1, self.3) }
fn zzx(self) -> (C, C, A) { (self.2, self.2, self.0) }
fn zzy(self) -> (C, C, B) { (self.2, self.2, self.1) }
fn zzz(self) -> (C, C, C) { (self.2, self.2, self.2) }
fn zzw(self) -> (C, C, D) { (self.2, self.2, self.3) }
fn zwx(self) -> (C, D, A) { (self.2, self.3, self.0) }
fn zwy(self) -> (C, D, B) { (self.2, self.3, self.1) }
fn zwz(self) -> (C, D, C) { (self.2, self.3, self.2) }
fn zww(self) -> (C, D, D) { (self.2, self.3, self.3) }
fn wxx(self) -> (D, A, A) { (self.3, self.0, self.0) }
fn wxy(self) -> (D, A, B) { (self.3, self.0, self.1) }
fn wxz(self) -> (D, A, C) { (self.3, self.0, self.2) }
fn wxw(self) -> (D, A, D) { (self.3, self.0, self.3) }
fn wyx(self) -> (D, B, A) { (self.3, self.1, self.0) }
fn wyy(self) -> (D, B, B) { (self.3, self.1, self.1) }
fn wyz(self) -> (D, B, C) { (self.3, self.1, self.2) }
fn wyw(self) -> (D, B, D) { (self.3, self.1, self.3) }
fn wzx(self) -> (D, C, A) { (self.3, self.2, self.0) }
fn wzy(self) -> (D, C, B) { (self.3, self.2, self.1) }
fn wzz(self) -> (D, C, C) { (self.3, self.2, self.2) }
fn wzw(self) -> (D, C, D) { (self.3, self.2, self.3) }
fn wwx(self) -> (D, D, A) { (self.3, self.3, self.0) }
fn wwy(self) -> (D, D, B) { (self.3, self.3, self.1) }
fn wwz(self) -> (D, D, C) { (self.3, self.3, self.2) }
fn www(self) -> (D, D, D) { (self.3, self.3, self.3) }
fn xxxx(self) -> (A, A, A, A) { (self.0, self.0, self.0, self.0) }
fn xxxy(self) -> (A, A, A, B) { (self.0, self.0, self.0, self.1) }
fn xxxz(self) -> (A, A, A, C) { (self.0, self.0, self.0, self.2) }
fn xxxw(self) -> (A, A, A, D) { (self.0, self.0, self.0, self.3) }
fn xxyx(self) -> (A, A, B, A) { (self.0, self.0, self.1, self.0) }
fn xxyy(self) -> (A, A, B, B) { (self.0, self.0, self.1, self.1) }
fn xxyz(self) -> (A, A, B, C) { (self.0, self.0, self.1, self.2) }
fn xxyw(self) -> (A, A, B, D) { (self.0, self.0, self.1, self.3) }
fn xxzx(self) -> (A, A, C, A) { (self.0, self.0, self.2, self.0) }
fn xxzy(self) -> (A, A, C, B) { (self.0, self.0, self.2, self.1) }
fn xxzz(self) -> (A, A, C, C) { (self.0, self.0, self.2, self.2) }
fn xxzw(self) -> (A, A, C, D) { (self.0, self.0, self.2, self.3) }
fn xxwx(self) -> (A, A, D, A) { (self.0, self.0, self.3, self.0) }
fn xxwy(self) -> (A, A, D, B) { (self.0, self.0, self.3, self.1) }
fn xxwz(self) -> (A, A, D, C) { (self.0, self.0, self.3, self.2) }
fn xxww(self) -> (A, A, D, D) { (self.0, self.0, self.3, self.3) }
fn xyxx(self) -> (A, B, A, A) { (self.0, self.1, self.0, self.0) }
fn xyxy(self) -> (A, B, A, B) { (self.0, self.1, self.0, self.1) }
fn xyxz(self) -> (A, B, A, C) { (self.0, self.1, self.0, self.2) }
fn xyxw(self) -> (A, B, A, D) { (self.0, self.1, self.0, self.3) }
fn xyyx(self) -> (A, B, B, A) { (self.0, self.1, self.1, self.0) }
fn xyyy(self) -> (A, B, B, B) { (self.0, self.1, self.1, self.1) }
fn xyyz(self) -> (A, B, B, C) { (self.0, self.1, self.1, self.2) }
fn xyyw(self) -> (A, B, B, D) { (self.0, self.1, self.1, self.3) }
fn xyzx(self) -> (A, B, C, A) { (self.0, self.1, self.2, self.0) }
fn xyzy(self) -> (A, B, C, B) { (self.0, self.1, self.2, self.1) }
fn xyzz(self) -> (A, B, C, C) { (self.0, self.1, self.2, self.2) }
fn xyzw(self) -> (A, B, C, D) { (self.0, self.1, self.2, self.3) }
fn xywx(self) -> (A, B, D, A) { (self.0, self.1, self.3, self.0) }
fn xywy(self) -> (A, B, D, B) { (self.0, self.1, self.3, self.1) }
fn xywz(self) -> (A, B, D, C) { (self.0, self.1, self.3, self.2) }
fn xyww(self) -> (A, B, D, D) { (self.0, self.1, self.3, self.3) }
fn xzxx(self) -> (A, C, A, A) { (self.0, self.2, self.0, self.0) }
fn xzxy(self) -> (A, C, A, B) { (self.0, self.2, self.0, self.1) }
fn xzxz(self) -> (A, C, A, C) { (self.0, self.2, self.0, self.2) }
fn xzxw(self) -> (A, C, A, D) { (self.0, self.2, self.0, self.3) }
fn xzyx(self) -> (A, C, B, A) { (self.0, self.2, self.1, self.0) }
fn xzyy(self) -> (A, C, B, B) { (self.0, self.2, self.1, self.1) }
fn xzyz(self) -> (A, C, B, C) { (self.0, self.2, self.1, self.2) }
fn xzyw(self) -> (A, C, B, D) { (self.0, self.2, self.1, self.3) }
fn xzzx(self) -> (A, C, C, A) { (self.0, self.2, self.2, self.0) }
fn xzzy(self) -> (A, C, C, B) { (self.0, self.2, self.2, self.1) }
fn xzzz(self) -> (A, C, C, C) { (self.0, self.2, self.2, self.2) }
fn xzzw(self) -> (A, C, C, D) { (self.0, self.2, self.2, self.3) }
fn xzwx(self) -> (A, C, D, A) { (self.0, self.2, self.3, self.0) }
fn xzwy(self) -> (A, C, D, B) { (self.0, self.2, self.3, self.1) }
fn xzwz(self) -> (A, C, D, C) { (self.0, self.2, self.3, self.2) }
fn xzww(self) -> (A, C, D, D) { (self.0, self.2, self.3, self.3) }
fn xwxx(self) -> (A, D, A, A) { (self.0, self.3, self.0, self.0) }
fn xwxy(self) -> (A, D, A, B) { (self.0, self.3, self.0, self.1) }
fn xwxz(self) -> (A, D, A, C) { (self.0, self.3, self.0, self.2) }
fn xwxw(self) -> (A, D, A, D) { (self.0, self.3, self.0, self.3) }
fn xwyx(self) -> (A, D, B, A) { (self.0, self.3, self.1, self.0) }
fn xwyy(self) -> (A, D, B, B) { (self.0, self.3, self.1, self.1) }
fn xwyz(self) -> (A, D, B, C) { (self.0, self.3, self.1, self.2) }
fn xwyw(self) -> (A, D, B, D) { (self.0, self.3, self.1, self.3) }
fn xwzx(self) -> (A, D, C, A) { (self.0, self.3, self.2, self.0) }
fn xwzy(self) -> (A, D, C, B) { (self.0, self.3, self.2, self.1) }
fn xwzz(self) -> (A, D, C, C) { (self.0, self.3, self.2, self.2) }
fn xwzw(self) -> (A, D, C, D) { (self.0, self.3, self.2, self.3) }
fn xwwx(self) -> (A, D, D, A) { (self.0, self.3, self.3, self.0) }
fn xwwy(self) -> (A, D, D, B) { (self.0, self.3, self.3, self.1) }
fn xwwz(self) -> (A, D, D, C) { (self.0, self.3, self.3, self.2) }
fn xwww(self) -> (A, D, D, D) { (self.0, self.3, self.3, self.3) }
fn yxxx(self) -> (B, A, A, A) { (self.1, self.0, self.0, self.0) }
fn yxxy(self) -> (B, A, A, B) { (self.1, self.0, self.0, self.1) }
fn yxxz(self) -> (B, A, A, C) { (self.1, self.0, self.0, self.2) }
fn yxxw(self) -> (B, A, A, D) { (self.1, self.0, self.0, self.3) }
fn yxyx(self) -> (B, A, B, A) { (self.1, self.0, self.1, self.0) }
fn yxyy(self) -> (B, A, B, B) { (self.1, self.0, self.1, self.1) }
fn yxyz(self) -> (B, A, B, C) { (self.1, self.0, self.1, self.2) }
fn yxyw(self) -> (B, A, B, D) { (self.1, self.0, self.1, self.3) }
fn yxzx(self) -> (B, A, C, A) { (self.1, self.0, self.2, self.0) }
fn yxzy(self) -> (B, A, C, B) { (self.1, self.0, self.2, self.1) }
fn yxzz(self) -> (B, A, C, C) { (self.1, self.0, self.2, self.2) }
fn yxzw(self) -> (B, A, C, D) { (self.1, self.0, self.2, self.3) }
fn yxwx(self) -> (B, A, D, A) { (self.1, self.0, self.3, self.0) }
fn yxwy(self) -> (B, A, D, B) { (self.1, self.0, self.3, self.1) }
fn yxwz(self) -> (B, A, D, C) { (self.1, self.0, self.3, self.2) }
fn yxww(self) -> (B, A, D, D) { (self.1, self.0, self.3, self.3) }
fn yyxx(self) -> (B, B, A, A) { (self.1, self.1, self.0, self.0) }
fn yyxy(self) -> (B, B, A, B) { (self.1, self.1, self.0, self.1) }
fn yyxz(self) -> (B, B, A, C) { (self.1, self.1, self.0, self.2) }
fn yyxw(self) -> (B, B, A, D) { (self.1, self.1, self.0, self.3) }
fn yyyx(self) -> (B, B, B, A) { (self.1, self.1, self.1, self.0) }
fn yyyy(self) -> (B, B, B, B) { (self.1, self.1, self.1, self.1) }
fn yyyz(self) -> (B, B, B, C) { (self.1, self.1, self.1, self.2) }
fn yyyw(self) -> (B, B, B, D) { (self.1, self.1, self.1, self.3) }
fn yyzx(self) -> (B, B, C, A) { (self.1, self.1, self.2, self.0) }
fn yyzy(self) -> (B, B, C, B) { (self.1, self.1, self.2, self.1) }
fn yyzz(self) -> (B, B, C, C) { (self.1, self.1, self.2, self.2) }
fn yyzw(self) -> (B, B, C, D) { (self.1, self.1, self.2, self.3) }
fn yywx(self) -> (B, B, D, A) { (self.1, self.1, self.3, self.0) }
fn yywy(self) -> (B, B, D, B) { (self.1, self.1, self.3, self.1) }
fn yywz(self) -> (B, B, D, C) { (self.1, self.1, self.3, self.2) }
fn yyww(self) -> (B, B, D, D) { (self.1, self.1, self.3, self.3) }
fn yzxx(self) -> (B, C, A, A) { (self.1, self.2, self.0, self.0) }
fn yzxy(self) -> (B, C, A, B) { (self.1, self.2, self.0, self.1) }
fn yzxz(self) -> (B, C, A, C) { (self.1, self.2, self.0, self.2) }
fn yzxw(self) -> (B, C, A, D) { (self.1, self.2, self.0, self.3) }
fn yzyx(self) -> (B, C, B, A) { (self.1, self.2, self.1, self.0) }
fn yzyy(self) -> (B, C, B, B) { (self.1, self.2, self.1, self.1) }
fn yzyz(self) -> (B, C, B, C) { (self.1, self.2, self.1, self.2) }
fn yzyw(self) -> (B, C, B, D) { (self.1, self.2, self.1, self.3) }
fn yzzx(self) -> (B, C, C, A) { (self.1, self.2, self.2, self.0) }
fn yzzy(self) -> (B, C, C, B) { (self.1, self.2, self.2, self.1) }
fn yzzz(self) -> (B, C, C, C) { (self.1, self.2, self.2, self.2) }
fn yzzw(self) -> (B, C, C, D) { (self.1, self.2, self.2, self.3) }
fn yzwx(self) -> (B, C, D, A) { (self.1, self.2, self.3, self.0) }
fn yzwy(self) -> (B, C, D, B) { (self.1, self.2, self.3, self.1) }
fn yzwz(self) -> (B, C, D, C) { (self.1, self.2, self.3, self.2) }
fn yzww(self) -> (B, C, D, D) { (self.1, self.2, self.3, self.3) }
fn ywxx(self) -> (B, D, A, A) { (self.1, self.3, self.0, self.0) }
fn ywxy(self) -> (B, D, A, B) { (self.1, self.3, self.0, self.1) }
fn ywxz(self) -> (B, D, A, C) { (self.1, self.3, self.0, self.2) }
fn ywxw(self) -> (B, D, A, D) { (self.1, self.3, self.0, self.3) }
fn ywyx(self) -> (B, D, B, A) { (self.1, self.3, self.1, self.0) }
fn ywyy(self) -> (B, D, B, B) { (self.1, self.3, self.1, self.1) }
fn ywyz(self) -> (B, D, B, C) { (self.1, self.3, self.1, self.2) }
fn ywyw(self) -> (B, D, B, D) { (self.1, self.3, self.1, self.3) }
fn ywzx(self) -> (B, D, C, A) { (self.1, self.3, self.2, self.0) }
fn ywzy(self) -> (B, D, C, B) { (self.1, self.3, self.2, self.1) }
fn ywzz(self) -> (B, D, C, C) { (self.1, self.3, self.2, self.2) }
fn ywzw(self) -> (B, D, C, D) { (self.1, self.3, self.2, self.3) }
fn ywwx(self) -> (B, D, D, A) { (self.1, self.3, self.3, self.0) }
fn ywwy(self) -> (B, D, D, B) { (self.1, self.3, self.3, self.1) }
fn ywwz(self) -> (B, D, D, C) { (self.1, self.3, self.3, self.2) }
fn ywww(self) -> (B, D, D, D) { (self.1, self.3, self.3, self.3) }
fn zxxx(self) -> (C, A, A, A) { (self.2, self.0, self.0, self.0) }
fn zxxy(self) -> (C, A, A, B) { (self.2, self.0, self.0, self.1) }
fn zxxz(self) -> (C, A, A, C) { (self.2, self.0, self.0, self.2) }
fn zxxw(self) -> (C, A, A, D) { (self.2, self.0, self.0, self.3) }
fn zxyx(self) -> (C, A, B, A) { (self.2, self.0, self.1, self.0) }
fn zxyy(self) -> (C, A, B, B) { (self.2, self.0, self.1, self.1) }
fn zxyz(self) -> (C, A, B, C) { (self.2, self.0, self.1, self.2) }
fn zxyw(self) -> (C, A, B, D) { (self.2, self.0, self.1, self.3) }
fn zxzx(self) -> (C, A, C, A) { (self.2, self.0, self.2, self.0) }
fn zxzy(self) -> (C, A, C, B) { (self.2, self.0, self.2, self.1) }
fn zxzz(self) -> (C, A, C, C) { (self.2, self.0, self.2, self.2) }
fn zxzw(self) -> (C, A, C, D) { (self.2, self.0, self.2, self.3) }
fn zxwx(self) -> (C, A, D, A) { (self.2, self.0, self.3, self.0) }
fn zxwy(self) -> (C, A, D, B) { (self.2, self.0, self.3, self.1) }
fn zxwz(self) -> (C, A, D, C) { (self.2, self.0, self.3, self.2) }
fn zxww(self) -> (C, A, D, D) { (self.2, self.0, self.3, self.3) }
fn zyxx(self) -> (C, B, A, A) { (self.2, self.1, self.0, self.0) }
fn zyxy(self) -> (C, B, A, B) { (self.2, self.1, self.0, self.1) }
fn zyxz(self) -> (C, B, A, C) { (self.2, self.1, self.0, self.2) }
fn zyxw(self) -> (C, B, A, D) { (self.2, self.1, self.0, self.3) }
fn zyyx(self) -> (C, B, B, A) { (self.2, self.1, self.1, self.0) }
fn zyyy(self) -> (C, B, B, B) { (self.2, self.1, self.1, self.1) }
fn zyyz(self) -> (C, B, B, C) { (self.2, self.1, self.1, self.2) }
fn zyyw(self) -> (C, B, B, D) { (self.2, self.1, self.1, self.3) }
fn zyzx(self) -> (C, B, C, A) { (self.2, self.1, self.2, self.0) }
fn zyzy(self) -> (C, B, C, B) { (self.2, self.1, self.2, self.1) }
fn zyzz(self) -> (C, B, C, C) { (self.2, self.1, self.2, self.2) }
fn zyzw(self) -> (C, B, C, D) { (self.2, self.1, self.2, self.3) }
fn zywx(self) -> (C, B, D, A) { (self.2, self.1, self.3, self.0) }
fn zywy(self) -> (C, B, D, B) { (self.2, self.1, self.3, self.1) }
fn zywz(self) -> (C, B, D, C) { (self.2, self.1, self.3, self.2) }
fn zyww(self) -> (C, B, D, D) { (self.2, self.1, self.3, self.3) }
fn zzxx(self) -> (C, C, A, A) { (self.2, self.2, self.0, self.0) }
fn zzxy(self) -> (C, C, A, B) { (self.2, self.2, self.0, self.1) }
fn zzxz(self) -> (C, C, A, C) { (self.2, self.2, self.0, self.2) }
fn zzxw(self) -> (C, C, A, D) { (self.2, self.2, self.0, self.3) }
fn zzyx(self) -> (C, C, B, A) { (self.2, self.2, self.1, self.0) }
fn zzyy(self) -> (C, C, B, B) { (self.2, self.2, self.1, self.1) }
fn zzyz(self) -> (C, C, B, C) { (self.2, self.2, self.1, self.2) }
fn zzyw(self) -> (C, C, B, D) { (self.2, self.2, self.1, self.3) }
fn zzzx(self) -> (C, C, C, A) { (self.2, self.2, self.2, self.0) }
fn zzzy(self) -> (C, C, C, B) { (self.2, self.2, self.2, self.1) }
fn zzzz(self) -> (C, C, C, C) { (self.2, self.2, self.2, self.2) }
fn zzzw(self) -> (C, C, C, D) { (self.2, self.2, self.2, self.3) }
fn zzwx(self) -> (C, C, D, A) { (self.2, self.2, self.3, self.0) }
fn zzwy(self) -> (C, C, D, B) { (self.2, self.2, self.3, self.1) }
fn zzwz(self) -> (C, C, D, C) { (self.2, self.2, self.3, self.2) }
fn zzww(self) -> (C, C, D, D) { (self.2, self.2, self.3, self.3) }
fn zwxx(self) -> (C, D, A, A) { (self.2, self.3, self.0, self.0) }
fn zwxy(self) -> (C, D, A, B) { (self.2, self.3, self.0, self.1) }
fn zwxz(self) -> (C, D, A, C) { (self.2, self.3, self.0, self.2) }
fn zwxw(self) -> (C, D, A, D) { (self.2, self.3, self.0, self.3) }
fn zwyx(self) -> (C, D, B, A) { (self.2, self.3, self.1, self.0) }
fn zwyy(self) -> (C, D, B, B) { (self.2, self.3, self.1, self.1) }
fn zwyz(self) -> (C, D, B, C) { (self.2, self.3, self.1, self.2) }
fn zwyw(self) -> (C, D, B, D) { (self.2, self.3, self.1, self.3) }
fn zwzx(self) -> (C, D, C, A) { (self.2, self.3, self.2, self.0) }
fn zwzy(self) -> (C, D, C, B) { (self.2, self.3, self.2, self.1) }
fn zwzz(self) -> (C, D, C, C) { (self.2, self.3, self.2, self.2) }
fn zwzw(self) -> (C, D, C, D) { (self.2, self.3, self.2, self.3) }
fn zwwx(self) -> (C, D, D, A) { (self.2, self.3, self.3, self.0) }
fn zwwy(self) -> (C, D, D, B) { (self.2, self.3, self.3, self.1) }
fn zwwz(self) -> (C, D, D, C) { (self.2, self.3, self.3, self.2) }
fn zwww(self) -> (C, D, D, D) { (self.2, self.3, self.3, self.3) }
fn wxxx(self) -> (D, A, A, A) { (self.3, self.0, self.0, self.0) }
fn wxxy(self) -> (D, A, A, B) { (self.3, self.0, self.0, self.1) }
fn wxxz(self) -> (D, A, A, C) { (self.3, self.0, self.0, self.2) }
fn wxxw(self) -> (D, A, A, D) { (self.3, self.0, self.0, self.3) }
fn wxyx(self) -> (D, A, B, A) { (self.3, self.0, self.1, self.0) }
fn wxyy(self) -> (D, A, B, B) { (self.3, self.0, self.1, self.1) }
fn wxyz(self) -> (D, A, B, C) { (self.3, self.0, self.1, self.2) }
fn wxyw(self) -> (D, A, B, D) { (self.3, self.0, self.1, self.3) }
fn wxzx(self) -> (D, A, C, A) { (self.3, self.0, self.2, self.0) }
fn wxzy(self) -> (D, A, C, B) { (self.3, self.0, self.2, self.1) }
fn wxzz(self) -> (D, A, C, C) { (self.3, self.0, self.2, self.2) }
fn wxzw(self) -> (D, A, C, D) { (self.3, self.0, self.2, self.3) }
fn wxwx(self) -> (D, A, D, A) { (self.3, self.0, self.3, self.0) }
fn wxwy(self) -> (D, A, D, B) { (self.3, self.0, self.3, self.1) }
fn wxwz(self) -> (D, A, D, C) { (self.3, self.0, self.3, self.2) }
fn wxww(self) -> (D, A, D, D) { (self.3, self.0, self.3, self.3) }
fn wyxx(self) -> (D, B, A, A) { (self.3, self.1, self.0, self.0) }
fn wyxy(self) -> (D, B, A, B) { (self.3, self.1, self.0, self.1) }
fn wyxz(self) -> (D, B, A, C) { (self.3, self.1, self.0, self.2) }
fn wyxw(self) -> (D, B, A, D) { (self.3, self.1, self.0, self.3) }
fn wyyx(self) -> (D, B, B, A) { (self.3, self.1, self.1, self.0) }
fn wyyy(self) -> (D, B, B, B) { (self.3, self.1, self.1, self.1) }
fn wyyz(self) -> (D, B, B, C) { (self.3, self.1, self.1, self.2) }
fn wyyw(self) -> (D, B, B, D) { (self.3, self.1, self.1, self.3) }
fn wyzx(self) -> (D, B, C, A) { (self.3, self.1, self.2, self.0) }
fn wyzy(self) -> (D, B, C, B) { (self.3, self.1, self.2, self.1) }
fn wyzz(self) -> (D, B, C, C) { (self.3, self.1, self.2, self.2) }
fn wyzw(self) -> (D, B, C, D) { (self.3, self.1, self.2, self.3) }
fn wywx(self) -> (D, B, D, A) { (self.3, self.1, self.3, self.0) }
fn wywy(self) -> (D, B, D, B) { (self.3, self.1, self.3, self.1) }
fn wywz(self) -> (D, B, D, C) { (self.3, self.1, self.3, self.2) }
fn wyww(self) -> (D, B, D, D) { (self.3, self.1, self.3, self.3) }
fn wzxx(self) -> (D, C, A, A) { (self.3, self.2, self.0, self.0) }
fn wzxy(self) -> (D, C, A, B) { (self.3, self.2, self.0, self.1) }
fn wzxz(self) -> (D, C, A, C) { (self.3, self.2, self.0, self.2) }
fn wzxw(self) -> (D, C, A, D) { (self.3, self.2, self.0, self.3) }
fn wzyx(self) -> (D, C, B, A) { (self.3, self.2, self.1, self.0) }
fn wzyy(self) -> (D, C, B, B) { (self.3, self.2, self.1, self.1) }
fn wzyz(self) -> (D, C, B, C) { (self.3, self.2, self.1, self.2) }
fn wzyw(self) -> (D, C, B, D) { (self.3, self.2, self.1, self.3) }
fn wzzx(self) -> (D, C, C, A) { (self.3, self.2, self.2, self.0) }
fn wzzy(self) -> (D, C, C, B) { (self.3, self.2, self.2, self.1) }
fn wzzz(self) -> (D, C, C, C) { (self.3, self.2, self.2, self.2) }
fn wzzw(self) -> (D, C, C, D) { (self.3, self.2, self.2, self.3) }
fn wzwx(self) -> (D, C, D, A) { (self.3, self.2, self.3, self.0) }
fn wzwy(self) -> (D, C, D, B) { (self.3, self.2, self.3, self.1) }
fn wzwz(self) -> (D, C, D, C) { (self.3, self.2, self.3, self.2) }
fn wzww(self) -> (D, C, D, D) { (self.3, self.2, self.3, self.3) }
fn wwxx(self) -> (D, D, A, A) { (self.3, self.3, self.0, self.0) }
fn wwxy(self) -> (D, D, A, B) { (self.3, self.3, self.0, self.1) }
fn wwxz(self) -> (D, D, A, C) { (self.3, self.3, self.0, self.2) }
fn wwxw(self) -> (D, D, A, D) { (self.3, self.3, self.0, self.3) }
fn wwyx(self) -> (D, D, B, A) { (self.3, self.3, self.1, self.0) }
fn wwyy(self) -> (D, D, B, B) { (self.3, self.3, self.1, self.1) }
fn wwyz(self) -> (D, D, B, C) { (self.3, self.3, self.1, self.2) }
fn wwyw(self) -> (D, D, B, D) { (self.3, self.3, self.1, self.3) }
fn wwzx(self) -> (D, D, C, A) { (self.3, self.3, self.2, self.0) }
fn wwzy(self) -> (D, D, C, B) { (self.3, self.3, self.2, self.1) }
fn wwzz(self) -> (D, D, C, C) { (self.3, self.3, self.2, self.2) }
fn wwzw(self) -> (D, D, C, D) { (self.3, self.3, self.2, self.3) }
fn wwwx(self) -> (D, D, D, A) { (self.3, self.3, self.3, self.0) }
fn wwwy(self) -> (D, D, D, B) { (self.3, self.3, self.3, self.1) }
fn wwwz(self) -> (D, D, D, C) { (self.3, self.3, self.3, self.2) }
fn wwww(self) -> (D, D, D, D) { (self.3, self.3, self.3, self.3) }
fn r(self) -> A { self.0 }
fn g(self) -> B { self.1 }
fn b(self) -> C { self.2 }
fn a(self) -> D { self.3 }
fn rr(self) -> (A, A) { (self.0, self.0) }
fn rg(self) -> (A, B) { (self.0, self.1) }
fn rb(self) -> (A, C) { (self.0, self.2) }
fn ra(self) -> (A, D) { (self.0, self.3) }
fn gr(self) -> (B, A) { (self.1, self.0) }
fn gg(self) -> (B, B) { (self.1, self.1) }
fn gb(self) -> (B, C) { (self.1, self.2) }
fn ga(self) -> (B, D) { (self.1, self.3) }
fn br(self) -> (C, A) { (self.2, self.0) }
fn bg(self) -> (C, B) { (self.2, self.1) }
fn bb(self) -> (C, C) { (self.2, self.2) }
fn ba(self) -> (C, D) { (self.2, self.3) }
fn ar(self) -> (D, A) { (self.3, self.0) }
fn ag(self) -> (D, B) { (self.3, self.1) }
fn ab(self) -> (D, C) { (self.3, self.2) }
fn aa(self) -> (D, D) { (self.3, self.3) }
fn rrr(self) -> (A, A, A) { (self.0, self.0, self.0) }
fn rrg(self) -> (A, A, B) { (self.0, self.0, self.1) }
fn rrb(self) -> (A, A, C) { (self.0, self.0, self.2) }
fn rra(self) -> (A, A, D) { (self.0, self.0, self.3) }
fn rgr(self) -> (A, B, A) { (self.0, self.1, self.0) }
fn rgg(self) -> (A, B, B) { (self.0, self.1, self.1) }
fn rgb(self) -> (A, B, C) { (self.0, self.1, self.2) }
fn rga(self) -> (A, B, D) { (self.0, self.1, self.3) }
fn rbr(self) -> (A, C, A) { (self.0, self.2, self.0) }
fn rbg(self) -> (A, C, B) { (self.0, self.2, self.1) }
fn rbb(self) -> (A, C, C) { (self.0, self.2, self.2) }
fn rba(self) -> (A, C, D) { (self.0, self.2, self.3) }
fn rar(self) -> (A, D, A) { (self.0, self.3, self.0) }
fn rag(self) -> (A, D, B) { (self.0, self.3, self.1) }
fn rab(self) -> (A, D, C) { (self.0, self.3, self.2) }
fn raa(self) -> (A, D, D) { (self.0, self.3, self.3) }
fn grr(self) -> (B, A, A) { (self.1, self.0, self.0) }
fn grg(self) -> (B, A, B) { (self.1, self.0, self.1) }
fn grb(self) -> (B, A, C) { (self.1, self.0, self.2) }
fn gra(self) -> (B, A, D) { (self.1, self.0, self.3) }
fn ggr(self) -> (B, B, A) { (self.1, self.1, self.0) }
fn ggg(self) -> (B, B, B) { (self.1, self.1, self.1) }
fn ggb(self) -> (B, B, C) { (self.1, self.1, self.2) }
fn gga(self) -> (B, B, D) { (self.1, self.1, self.3) }
fn gbr(self) -> (B, C, A) { (self.1, self.2, self.0) }
fn gbg(self) -> (B, C, B) { (self.1, self.2, self.1) }
fn gbb(self) -> (B, C, C) { (self.1, self.2, self.2) }
fn gba(self) -> (B, C, D) { (self.1, self.2, self.3) }
fn gar(self) -> (B, D, A) { (self.1, self.3, self.0) }
fn gag(self) -> (B, D, B) { (self.1, self.3, self.1) }
fn gab(self) -> (B, D, C) { (self.1, self.3, self.2) }
fn gaa(self) -> (B, D, D) { (self.1, self.3, self.3) }
fn brr(self) -> (C, A, A) { (self.2, self.0, self.0) }
fn brg(self) -> (C, A, B) { (self.2, self.0, self.1) }
fn brb(self) -> (C, A, C) { (self.2, self.0, self.2) }
fn bra(self) -> (C, A, D) { (self.2, self.0, self.3) }
fn bgr(self) -> (C, B, A) { (self.2, self.1, self.0) }
fn bgg(self) -> (C, B, B) { (self.2, self.1, self.1) }
fn bgb(self) -> (C, B, C) { (self.2, self.1, self.2) }
fn bga(self) -> (C, B, D) { (self.2, self.1, self.3) }
fn bbr(self) -> (C, C, A) { (self.2, self.2, self.0) }
fn bbg(self) -> (C, C, B) { (self.2, self.2, self.1) }
fn bbb(self) -> (C, C, C) { (self.2, self.2, self.2) }
fn bba(self) -> (C, C, D) { (self.2, self.2, self.3) }
fn bar(self) -> (C, D, A) { (self.2, self.3, self.0) }
fn bag(self) -> (C, D, B) { (self.2, self.3, self.1) }
fn bab(self) -> (C, D, C) { (self.2, self.3, self.2) }
fn baa(self) -> (C, D, D) { (self.2, self.3, self.3) }
fn arr(self) -> (D, A, A) { (self.3, self.0, self.0) }
fn arg(self) -> (D, A, B) { (self.3, self.0, self.1) }
fn arb(self) -> (D, A, C) { (self.3, self.0, self.2) }
fn ara(self) -> (D, A, D) { (self.3, self.0, self.3) }
fn agr(self) -> (D, B, A) { (self.3, self.1, self.0) }
fn agg(self) -> (D, B, B) { (self.3, self.1, self.1) }
fn agb(self) -> (D, B, C) { (self.3, self.1, self.2) }
fn aga(self) -> (D, B, D) { (self.3, self.1, self.3) }
fn abr(self) -> (D, C, A) { (self.3, self.2, self.0) }
fn abg(self) -> (D, C, B) { (self.3, self.2, self.1) }
fn abb(self) -> (D, C, C) { (self.3, self.2, self.2) }
fn aba(self) -> (D, C, D) { (self.3, self.2, self.3) }
fn aar(self) -> (D, D, A) { (self.3, self.3, self.0) }
fn aag(self) -> (D, D, B) { (self.3, self.3, self.1) }
fn aab(self) -> (D, D, C) { (self.3, self.3, self.2) }
fn aaa(self) -> (D, D, D) { (self.3, self.3, self.3) }
fn rrrr(self) -> (A, A, A, A) { (self.0, self.0, self.0, self.0) }
fn rrrg(self) -> (A, A, A, B) { (self.0, self.0, self.0, self.1) }
fn rrrb(self) -> (A, A, A, C) { (self.0, self.0, self.0, self.2) }
fn rrra(self) -> (A, A, A, D) { (self.0, self.0, self.0, self.3) }
fn rrgr(self) -> (A, A, B, A) { (self.0, self.0, self.1, self.0) }
fn rrgg(self) -> (A, A, B, B) { (self.0, self.0, self.1, self.1) }
fn rrgb(self) -> (A, A, B, C) { (self.0, self.0, self.1, self.2) }
fn rrga(self) -> (A, A, B, D) { (self.0, self.0, self.1, self.3) }
fn rrbr(self) -> (A, A, C, A) { (self.0, self.0, self.2, self.0) }
fn rrbg(self) -> (A, A, C, B) { (self.0, self.0, self.2, self.1) }
fn rrbb(self) -> (A, A, C, C) { (self.0, self.0, self.2, self.2) }
fn rrba(self) -> (A, A, C, D) { (self.0, self.0, self.2, self.3) }
fn rrar(self) -> (A, A, D, A) { (self.0, self.0, self.3, self.0) }
fn rrag(self) -> (A, A, D, B) { (self.0, self.0, self.3, self.1) }
fn rrab(self) -> (A, A, D, C) { (self.0, self.0, self.3, self.2) }
fn rraa(self) -> (A, A, D, D) { (self.0, self.0, self.3, self.3) }
fn rgrr(self) -> (A, B, A, A) { (self.0, self.1, self.0, self.0) }
fn rgrg(self) -> (A, B, A, B) { (self.0, self.1, self.0, self.1) }
fn rgrb(self) -> (A, B, A, C) { (self.0, self.1, self.0, self.2) }
fn rgra(self) -> (A, B, A, D) { (self.0, self.1, self.0, self.3) }
fn rggr(self) -> (A, B, B, A) { (self.0, self.1, self.1, self.0) }
fn rggg(self) -> (A, B, B, B) { (self.0, self.1, self.1, self.1) }
fn rggb(self) -> (A, B, B, C) { (self.0, self.1, self.1, self.2) }
fn rgga(self) -> (A, B, B, D) { (self.0, self.1, self.1, self.3) }
fn rgbr(self) -> (A, B, C, A) { (self.0, self.1, self.2, self.0) }
fn rgbg(self) -> (A, B, C, B) { (self.0, self.1, self.2, self.1) }
fn rgbb(self) -> (A, B, C, C) { (self.0, self.1, self.2, self.2) }
fn rgba(self) -> (A, B, C, D) { (self.0, self.1, self.2, self.3) }
fn rgar(self) -> (A, B, D, A) { (self.0, self.1, self.3, self.0) }
fn rgag(self) -> (A, B, D, B) { (self.0, self.1, self.3, self.1) }
fn rgab(self) -> (A, B, D, C) { (self.0, self.1, self.3, self.2) }
fn rgaa(self) -> (A, B, D, D) { (self.0, self.1, self.3, self.3) }
fn rbrr(self) -> (A, C, A, A) { (self.0, self.2, self.0, self.0) }
fn rbrg(self) -> (A, C, A, B) { (self.0, self.2, self.0, self.1) }
fn rbrb(self) -> (A, C, A, C) { (self.0, self.2, self.0, self.2) }
fn rbra(self) -> (A, C, A, D) { (self.0, self.2, self.0, self.3) }
fn rbgr(self) -> (A, C, B, A) { (self.0, self.2, self.1, self.0) }
fn rbgg(self) -> (A, C, B, B) { (self.0, self.2, self.1, self.1) }
fn rbgb(self) -> (A, C, B, C) { (self.0, self.2, self.1, self.2) }
fn rbga(self) -> (A, C, B, D) { (self.0, self.2, self.1, self.3) }
fn rbbr(self) -> (A, C, C, A) { (self.0, self.2, self.2, self.0) }
fn rbbg(self) -> (A, C, C, B) { (self.0, self.2, self.2, self.1) }
fn rbbb(self) -> (A, C, C, C) { (self.0, self.2, self.2, self.2) }
fn rbba(self) -> (A, C, C, D) { (self.0, self.2, self.2, self.3) }
fn rbar(self) -> (A, C, D, A) { (self.0, self.2, self.3, self.0) }
fn rbag(self) -> (A, C, D, B) { (self.0, self.2, self.3, self.1) }
fn rbab(self) -> (A, C, D, C) { (self.0, self.2, self.3, self.2) }
fn rbaa(self) -> (A, C, D, D) { (self.0, self.2, self.3, self.3) }
fn rarr(self) -> (A, D, A, A) { (self.0, self.3, self.0, self.0) }
fn rarg(self) -> (A, D, A, B) { (self.0, self.3, self.0, self.1) }
fn rarb(self) -> (A, D, A, C) { (self.0, self.3, self.0, self.2) }
fn rara(self) -> (A, D, A, D) { (self.0, self.3, self.0, self.3) }
fn ragr(self) -> (A, D, B, A) { (self.0, self.3, self.1, self.0) }
fn ragg(self) -> (A, D, B, B) { (self.0, self.3, self.1, self.1) }
fn ragb(self) -> (A, D, B, C) { (self.0, self.3, self.1, self.2) }
fn raga(self) -> (A, D, B, D) { (self.0, self.3, self.1, self.3) }
fn rabr(self) -> (A, D, C, A) { (self.0, self.3, self.2, self.0) }
fn rabg(self) -> (A, D, C, B) { (self.0, self.3, self.2, self.1) }
fn rabb(self) -> (A, D, C, C) { (self.0, self.3, self.2, self.2) }
fn raba(self) -> (A, D, C, D) { (self.0, self.3, self.2, self.3) }
fn raar(self) -> (A, D, D, A) { (self.0, self.3, self.3, self.0) }
fn raag(self) -> (A, D, D, B) { (self.0, self.3, self.3, self.1) }
fn raab(self) -> (A, D, D, C) { (self.0, self.3, self.3, self.2) }
fn raaa(self) -> (A, D, D, D) { (self.0, self.3, self.3, self.3) }
fn grrr(self) -> (B, A, A, A) { (self.1, self.0, self.0, self.0) }
fn grrg(self) -> (B, A, A, B) { (self.1, self.0, self.0, self.1) }
fn grrb(self) -> (B, A, A, C) { (self.1, self.0, self.0, self.2) }
fn grra(self) -> (B, A, A, D) { (self.1, self.0, self.0, self.3) }
fn grgr(self) -> (B, A, B, A) { (self.1, self.0, self.1, self.0) }
fn grgg(self) -> (B, A, B, B) { (self.1, self.0, self.1, self.1) }
fn grgb(self) -> (B, A, B, C) { (self.1, self.0, self.1, self.2) }
fn grga(self) -> (B, A, B, D) { (self.1, self.0, self.1, self.3) }
fn grbr(self) -> (B, A, C, A) { (self.1, self.0, self.2, self.0) }
fn grbg(self) -> (B, A, C, B) { (self.1, self.0, self.2, self.1) }
fn grbb(self) -> (B, A, C, C) { (self.1, self.0, self.2, self.2) }
fn grba(self) -> (B, A, C, D) { (self.1, self.0, self.2, self.3) }
fn grar(self) -> (B, A, D, A) { (self.1, self.0, self.3, self.0) }
fn grag(self) -> (B, A, D, B) { (self.1, self.0, self.3, self.1) }
fn grab(self) -> (B, A, D, C) { (self.1, self.0, self.3, self.2) }
fn graa(self) -> (B, A, D, D) { (self.1, self.0, self.3, self.3) }
fn ggrr(self) -> (B, B, A, A) { (self.1, self.1, self.0, self.0) }
fn ggrg(self) -> (B, B, A, B) { (self.1, self.1, self.0, self.1) }
fn ggrb(self) -> (B, B, A, C) { (self.1, self.1, self.0, self.2) }
fn ggra(self) -> (B, B, A, D) { (self.1, self.1, self.0, self.3) }
fn gggr(self) -> (B, B, B, A) { (self.1, self.1, self.1, self.0) }
fn gggg(self) -> (B, B, B, B) { (self.1, self.1, self.1, self.1) }
fn gggb(self) -> (B, B, B, C) { (self.1, self.1, self.1, self.2) }
fn ggga(self) -> (B, B, B, D) { (self.1, self.1, self.1, self.3) }
fn ggbr(self) -> (B, B, C, A) { (self.1, self.1, self.2, self.0) }
fn ggbg(self) -> (B, B, C, B) { (self.1, self.1, self.2, self.1) }
fn ggbb(self) -> (B, B, C, C) { (self.1, self.1, self.2, self.2) }
fn ggba(self) -> (B, B, C, D) { (self.1, self.1, self.2, self.3) }
fn ggar(self) -> (B, B, D, A) { (self.1, self.1, self.3, self.0) }
fn ggag(self) -> (B, B, D, B) { (self.1, self.1, self.3, self.1) }
fn ggab(self) -> (B, B, D, C) { (self.1, self.1, self.3, self.2) }
fn ggaa(self) -> (B, B, D, D) { (self.1, self.1, self.3, self.3) }
fn gbrr(self) -> (B, C, A, A) { (self.1, self.2, self.0, self.0) }
fn gbrg(self) -> (B, C, A, B) { (self.1, self.2, self.0, self.1) }
fn gbrb(self) -> (B, C, A, C) { (self.1, self.2, self.0, self.2) }
fn gbra(self) -> (B, C, A, D) { (self.1, self.2, self.0, self.3) }
fn gbgr(self) -> (B, C, B, A) { (self.1, self.2, self.1, self.0) }
fn gbgg(self) -> (B, C, B, B) { (self.1, self.2, self.1, self.1) }
fn gbgb(self) -> (B, C, B, C) { (self.1, self.2, self.1, self.2) }
fn gbga(self) -> (B, C, B, D) { (self.1, self.2, self.1, self.3) }
fn gbbr(self) -> (B, C, C, A) { (self.1, self.2, self.2, self.0) }
fn gbbg(self) -> (B, C, C, B) { (self.1, self.2, self.2, self.1) }
fn gbbb(self) -> (B, C, C, C) { (self.1, self.2, self.2, self.2) }
fn gbba(self) -> (B, C, C, D) { (self.1, self.2, self.2, self.3) }
fn gbar(self) -> (B, C, D, A) { (self.1, self.2, self.3, self.0) }
fn gbag(self) -> (B, C, D, B) { (self.1, self.2, self.3, self.1) }
fn gbab(self) -> (B, C, D, C) { (self.1, self.2, self.3, self.2) }
fn gbaa(self) -> (B, C, D, D) { (self.1, self.2, self.3, self.3) }
fn garr(self) -> (B, D, A, A) { (self.1, self.3, self.0, self.0) }
fn garg(self) -> (B, D, A, B) { (self.1, self.3, self.0, self.1) }
fn garb(self) -> (B, D, A, C) { (self.1, self.3, self.0, self.2) }
fn gara(self) -> (B, D, A, D) { (self.1, self.3, self.0, self.3) }
fn gagr(self) -> (B, D, B, A) { (self.1, self.3, self.1, self.0) }
fn gagg(self) -> (B, D, B, B) { (self.1, self.3, self.1, self.1) }
fn gagb(self) -> (B, D, B, C) { (self.1, self.3, self.1, self.2) }
fn gaga(self) -> (B, D, B, D) { (self.1, self.3, self.1, self.3) }
fn gabr(self) -> (B, D, C, A) { (self.1, self.3, self.2, self.0) }
fn gabg(self) -> (B, D, C, B) { (self.1, self.3, self.2, self.1) }
fn gabb(self) -> (B, D, C, C) { (self.1, self.3, self.2, self.2) }
fn gaba(self) -> (B, D, C, D) { (self.1, self.3, self.2, self.3) }
fn gaar(self) -> (B, D, D, A) { (self.1, self.3, self.3, self.0) }
fn gaag(self) -> (B, D, D, B) { (self.1, self.3, self.3, self.1) }
fn gaab(self) -> (B, D, D, C) { (self.1, self.3, self.3, self.2) }
fn gaaa(self) -> (B, D, D, D) { (self.1, self.3, self.3, self.3) }
fn brrr(self) -> (C, A, A, A) { (self.2, self.0, self.0, self.0) }
fn brrg(self) -> (C, A, A, B) { (self.2, self.0, self.0, self.1) }
fn brrb(self) -> (C, A, A, C) { (self.2, self.0, self.0, self.2) }
fn brra(self) -> (C, A, A, D) { (self.2, self.0, self.0, self.3) }
fn brgr(self) -> (C, A, B, A) { (self.2, self.0, self.1, self.0) }
fn brgg(self) -> (C, A, B, B) { (self.2, self.0, self.1, self.1) }
fn brgb(self) -> (C, A, B, C) { (self.2, self.0, self.1, self.2) }
fn brga(self) -> (C, A, B, D) { (self.2, self.0, self.1, self.3) }
fn brbr(self) -> (C, A, C, A) { (self.2, self.0, self.2, self.0) }
fn brbg(self) -> (C, A, C, B) { (self.2, self.0, self.2, self.1) }
fn brbb(self) -> (C, A, C, C) { (self.2, self.0, self.2, self.2) }
fn brba(self) -> (C, A, C, D) { (self.2, self.0, self.2, self.3) }
fn brar(self) -> (C, A, D, A) { (self.2, self.0, self.3, self.0) }
fn brag(self) -> (C, A, D, B) { (self.2, self.0, self.3, self.1) }
fn brab(self) -> (C, A, D, C) { (self.2, self.0, self.3, self.2) }
fn braa(self) -> (C, A, D, D) { (self.2, self.0, self.3, self.3) }
fn bgrr(self) -> (C, B, A, A) { (self.2, self.1, self.0, self.0) }
fn bgrg(self) -> (C, B, A, B) { (self.2, self.1, self.0, self.1) }
fn bgrb(self) -> (C, B, A, C) { (self.2, self.1, self.0, self.2) }
fn bgra(self) -> (C, B, A, D) { (self.2, self.1, self.0, self.3) }
fn bggr(self) -> (C, B, B, A) { (self.2, self.1, self.1, self.0) }
fn bggg(self) -> (C, B, B, B) { (self.2, self.1, self.1, self.1) }
fn bggb(self) -> (C, B, B, C) { (self.2, self.1, self.1, self.2) }
fn bgga(self) -> (C, B, B, D) { (self.2, self.1, self.1, self.3) }
fn bgbr(self) -> (C, B, C, A) { (self.2, self.1, self.2, self.0) }
fn bgbg(self) -> (C, B, C, B) { (self.2, self.1, self.2, self.1) }
fn bgbb(self) -> (C, B, C, C) { (self.2, self.1, self.2, self.2) }
fn bgba(self) -> (C, B, C, D) { (self.2, self.1, self.2, self.3) }
fn bgar(self) -> (C, B, D, A) { (self.2, self.1, self.3, self.0) }
fn bgag(self) -> (C, B, D, B) { (self.2, self.1, self.3, self.1) }
fn bgab(self) -> (C, B, D, C) { (self.2, self.1, self.3, self.2) }
fn bgaa(self) -> (C, B, D, D) { (self.2, self.1, self.3, self.3) }
fn bbrr(self) -> (C, C, A, A) { (self.2, self.2, self.0, self.0) }
fn bbrg(self) -> (C, C, A, B) { (self.2, self.2, self.0, self.1) }
fn bbrb(self) -> (C, C, A, C) { (self.2, self.2, self.0, self.2) }
fn bbra(self) -> (C, C, A, D) { (self.2, self.2, self.0, self.3) }
fn bbgr(self) -> (C, C, B, A) { (self.2, self.2, self.1, self.0) }
fn bbgg(self) -> (C, C, B, B) { (self.2, self.2, self.1, self.1) }
fn bbgb(self) -> (C, C, B, C) { (self.2, self.2, self.1, self.2) }
fn bbga(self) -> (C, C, B, D) { (self.2, self.2, self.1, self.3) }
fn bbbr(self) -> (C, C, C, A) { (self.2, self.2, self.2, self.0) }
fn bbbg(self) -> (C, C, C, B) { (self.2, self.2, self.2, self.1) }
fn bbbb(self) -> (C, C, C, C) { (self.2, self.2, self.2, self.2) }
fn bbba(self) -> (C, C, C, D) { (self.2, self.2, self.2, self.3) }
fn bbar(self) -> (C, C, D, A) { (self.2, self.2, self.3, self.0) }
fn bbag(self) -> (C, C, D, B) { (self.2, self.2, self.3, self.1) }
fn bbab(self) -> (C, C, D, C) { (self.2, self.2, self.3, self.2) }
fn bbaa(self) -> (C, C, D, D) { (self.2, self.2, self.3, self.3) }
fn barr(self) -> (C, D, A, A) { (self.2, self.3, self.0, self.0) }
fn barg(self) -> (C, D, A, B) { (self.2, self.3, self.0, self.1) }
fn barb(self) -> (C, D, A, C) { (self.2, self.3, self.0, self.2) }
fn bara(self) -> (C, D, A, D) { (self.2, self.3, self.0, self.3) }
fn bagr(self) -> (C, D, B, A) { (self.2, self.3, self.1, self.0) }
fn bagg(self) -> (C, D, B, B) { (self.2, self.3, self.1, self.1) }
fn bagb(self) -> (C, D, B, C) { (self.2, self.3, self.1, self.2) }
fn baga(self) -> (C, D, B, D) { (self.2, self.3, self.1, self.3) }
fn babr(self) -> (C, D, C, A) { (self.2, self.3, self.2, self.0) }
fn babg(self) -> (C, D, C, B) { (self.2, self.3, self.2, self.1) }
fn babb(self) -> (C, D, C, C) { (self.2, self.3, self.2, self.2) }
fn baba(self) -> (C, D, C, D) { (self.2, self.3, self.2, self.3) }
fn baar(self) -> (C, D, D, A) { (self.2, self.3, self.3, self.0) }
fn baag(self) -> (C, D, D, B) { (self.2, self.3, self.3, self.1) }
fn baab(self) -> (C, D, D, C) { (self.2, self.3, self.3, self.2) }
fn baaa(self) -> (C, D, D, D) { (self.2, self.3, self.3, self.3) }
fn arrr(self) -> (D, A, A, A) { (self.3, self.0, self.0, self.0) }
fn arrg(self) -> (D, A, A, B) { (self.3, self.0, self.0, self.1) }
fn arrb(self) -> (D, A, A, C) { (self.3, self.0, self.0, self.2) }
fn arra(self) -> (D, A, A, D) { (self.3, self.0, self.0, self.3) }
fn argr(self) -> (D, A, B, A) { (self.3, self.0, self.1, self.0) }
fn argg(self) -> (D, A, B, B) { (self.3, self.0, self.1, self.1) }
fn argb(self) -> (D, A, B, C) { (self.3, self.0, self.1, self.2) }
fn arga(self) -> (D, A, B, D) { (self.3, self.0, self.1, self.3) }
fn arbr(self) -> (D, A, C, A) { (self.3, self.0, self.2, self.0) }
fn arbg(self) -> (D, A, C, B) { (self.3, self.0, self.2, self.1) }
fn arbb(self) -> (D, A, C, C) { (self.3, self.0, self.2, self.2) }
fn arba(self) -> (D, A, C, D) { (self.3, self.0, self.2, self.3) }
fn arar(self) -> (D, A, D, A) { (self.3, self.0, self.3, self.0) }
fn arag(self) -> (D, A, D, B) { (self.3, self.0, self.3, self.1) }
fn arab(self) -> (D, A, D, C) { (self.3, self.0, self.3, self.2) }
fn araa(self) -> (D, A, D, D) { (self.3, self.0, self.3, self.3) }
fn agrr(self) -> (D, B, A, A) { (self.3, self.1, self.0, self.0) }
fn agrg(self) -> (D, B, A, B) { (self.3, self.1, self.0, self.1) }
fn agrb(self) -> (D, B, A, C) { (self.3, self.1, self.0, self.2) }
fn agra(self) -> (D, B, A, D) { (self.3, self.1, self.0, self.3) }
fn aggr(self) -> (D, B, B, A) { (self.3, self.1, self.1, self.0) }
fn aggg(self) -> (D, B, B, B) { (self.3, self.1, self.1, self.1) }
fn aggb(self) -> (D, B, B, C) { (self.3, self.1, self.1, self.2) }
fn agga(self) -> (D, B, B, D) { (self.3, self.1, self.1, self.3) }
fn agbr(self) -> (D, B, C, A) { (self.3, self.1, self.2, self.0) }
fn agbg(self) -> (D, B, C, B) { (self.3, self.1, self.2, self.1) }
fn agbb(self) -> (D, B, C, C) { (self.3, self.1, self.2, self.2) }
fn agba(self) -> (D, B, C, D) { (self.3, self.1, self.2, self.3) }
fn agar(self) -> (D, B, D, A) { (self.3, self.1, self.3, self.0) }
fn agag(self) -> (D, B, D, B) { (self.3, self.1, self.3, self.1) }
fn agab(self) -> (D, B, D, C) { (self.3, self.1, self.3, self.2) }
fn agaa(self) -> (D, B, D, D) { (self.3, self.1, self.3, self.3) }
fn abrr(self) -> (D, C, A, A) { (self.3, self.2, self.0, self.0) }
fn abrg(self) -> (D, C, A, B) { (self.3, self.2, self.0, self.1) }
fn abrb(self) -> (D, C, A, C) { (self.3, self.2, self.0, self.2) }
fn abra(self) -> (D, C, A, D) { (self.3, self.2, self.0, self.3) }
fn abgr(self) -> (D, C, B, A) { (self.3, self.2, self.1, self.0) }
fn abgg(self) -> (D, C, B, B) { (self.3, self.2, self.1, self.1) }
fn abgb(self) -> (D, C, B, C) { (self.3, self.2, self.1, self.2) }
fn abga(self) -> (D, C, B, D) { (self.3, self.2, self.1, self.3) }
fn abbr(self) -> (D, C, C, A) { (self.3, self.2, self.2, self.0) }
fn abbg(self) -> (D, C, C, B) { (self.3, self.2, self.2, self.1) }
fn abbb(self) -> (D, C, C, C) { (self.3, self.2, self.2, self.2) }
fn abba(self) -> (D, C, C, D) { (self.3, self.2, self.2, self.3) }
fn abar(self) -> (D, C, D, A) { (self.3, self.2, self.3, self.0) }
fn abag(self) -> (D, C, D, B) { (self.3, self.2, self.3, self.1) }
fn abab(self) -> (D, C, D, C) { (self.3, self.2, self.3, self.2) }
fn abaa(self) -> (D, C, D, D) { (self.3, self.2, self.3, self.3) }
fn aarr(self) -> (D, D, A, A) { (self.3, self.3, self.0, self.0) }
fn aarg(self) -> (D, D, A, B) { (self.3, self.3, self.0, self.1) }
fn aarb(self) -> (D, D, A, C) { (self.3, self.3, self.0, self.2) }
fn aara(self) -> (D, D, A, D) { (self.3, self.3, self.0, self.3) }
fn aagr(self) -> (D, D, B, A) { (self.3, self.3, self.1, self.0) }
fn aagg(self) -> (D, D, B, B) { (self.3, self.3, self.1, self.1) }
fn aagb(self) -> (D, D, B, C) { (self.3, self.3, self.1, self.2) }
fn aaga(self) -> (D, D, B, D) { (self.3, self.3, self.1, self.3) }
fn aabr(self) -> (D, D, C, A) { (self.3, self.3, self.2, self.0) }
fn aabg(self) -> (D, D, C, B) { (self.3, self.3, self.2, self.1) }
fn aabb(self) -> (D, D, C, C) { (self.3, self.3, self.2, self.2) }
fn aaba(self) -> (D, D, C, D) { (self.3, self.3, self.2, self.3) }
fn aaar(self) -> (D, D, D, A) { (self.3, self.3, self.3, self.0) }
fn aaag(self) -> (D, D, D, B) { (self.3, self.3, self.3, self.1) }
fn aaab(self) -> (D, D, D, C) { (self.3, self.3, self.3, self.2) }
fn aaaa(self) -> (D, D, D, D) { (self.3, self.3, self.3, self.3) }
}
}