#![allow(bad_style)]
#![allow(clippy::float_cmp)]
use hektor::*;
#[test]
fn Vec4_ww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.ww();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
}
#[test]
fn Vec4_www() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.www();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wwww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwww();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wwwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwwx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wwwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwwy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wwwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwwz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wwx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wwxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwxw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wwxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwxx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wwxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwxy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wwxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwxz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wwy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wwyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwyw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wwyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwyx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wwyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwyy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wwyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwyz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wwz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wwzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwzw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wwzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwzx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wwzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwzy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wwzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wwzz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.wx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
}
#[test]
fn Vec4_wxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wxw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wxww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxww();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wxwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxwx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wxwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxwy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wxwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxwz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wxx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wxxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxxw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wxxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxxx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wxxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxxy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wxxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxxz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wxy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wxyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxyw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wxyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxyx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wxyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxyy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wxyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxyz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wxz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wxzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxzw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wxzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxzx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wxzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxzy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wxzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wxzz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.wy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
}
#[test]
fn Vec4_wyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wyw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wyww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyww();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wywx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wywx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wywy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wywy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wywz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wywz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wyx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wyxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyxw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wyxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyxx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wyxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyxy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wyxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyxz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wyy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wyyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyyw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wyyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyyx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wyyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyyy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wyyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyyz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wyz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wyzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyzw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wyzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyzx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wyzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyzy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wyzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wyzz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.wz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
}
#[test]
fn Vec4_wzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wzw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wzww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzww();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wzwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzwx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wzwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzwy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wzwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzwz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_wzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wzx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wzxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzxw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wzxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzxx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wzxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzxy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wzxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzxz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_wzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wzy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wzyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzyw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wzyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzyx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wzyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzyy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wzyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzyz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_wzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.wzz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wzzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzzw();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wzzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzzx();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wzzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzzy();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_wzzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.wzzz();
  assert_eq!(v_swizzled.x(), v.w());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.xw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
}
#[test]
fn Vec4_xww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xww();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xwww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwww();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xwwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwwx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xwwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwwy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xwwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwwz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xwx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xwxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwxw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xwxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwxx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xwxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwxy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xwxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwxz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xwy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xwyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwyw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xwyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwyx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xwyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwyy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xwyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwyz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xwz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xwzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwzw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xwzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwzx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xwzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwzy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xwzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xwzz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.xx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
}
#[test]
fn Vec4_xxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xxw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xxww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxww();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xxwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxwx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xxwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxwy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xxwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxwz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xxx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xxxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxxw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xxxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxxx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xxxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxxy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xxxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxxz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xxy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xxyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxyw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xxyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxyx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xxyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxyy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xxyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxyz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xxz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xxzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxzw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xxzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxzx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xxzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxzy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xxzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xxzz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.xy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
}
#[test]
fn Vec4_xyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xyw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xyww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyww();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xywx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xywx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xywy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xywy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xywz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xywz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xyx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xyxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyxw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xyxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyxx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xyxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyxy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xyxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyxz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xyy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xyyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyyw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xyyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyyx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xyyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyyy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xyyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyyz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xyz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xyzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyzw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xyzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyzx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xyzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyzy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xyzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xyzz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.xz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
}
#[test]
fn Vec4_xzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xzw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xzww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzww();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xzwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzwx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xzwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzwy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xzwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzwz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_xzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xzx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xzxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzxw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xzxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzxx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xzxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzxy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xzxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzxz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_xzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xzy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xzyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzyw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xzyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzyx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xzyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzyy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xzyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzyz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_xzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.xzz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xzzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzzw();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xzzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzzx();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xzzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzzy();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_xzzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.xzzz();
  assert_eq!(v_swizzled.x(), v.x());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.yw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
}
#[test]
fn Vec4_yww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yww();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_ywww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywww();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_ywwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywwx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_ywwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywwy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_ywwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywwz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_ywx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.ywx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_ywxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywxw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_ywxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywxx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_ywxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywxy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_ywxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywxz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_ywy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.ywy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_ywyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywyw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_ywyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywyx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_ywyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywyy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_ywyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywyz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_ywz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.ywz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_ywzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywzw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_ywzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywzx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_ywzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywzy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_ywzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.ywzz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.yx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
}
#[test]
fn Vec4_yxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yxw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yxww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxww();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yxwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxwx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yxwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxwy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yxwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxwz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yxx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yxxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxxw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yxxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxxx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yxxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxxy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yxxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxxz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yxy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yxyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxyw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yxyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxyx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yxyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxyy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yxyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxyz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yxz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yxzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxzw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yxzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxzx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yxzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxzy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yxzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yxzz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.yy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
}
#[test]
fn Vec4_yyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yyw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yyww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyww();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yywx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yywx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yywy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yywy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yywz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yywz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yyx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yyxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyxw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yyxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyxx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yyxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyxy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yyxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyxz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yyy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yyyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyyw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yyyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyyx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yyyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyyy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yyyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyyz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yyz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yyzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyzw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yyzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyzx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yyzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyzy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yyzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yyzz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.yz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
}
#[test]
fn Vec4_yzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yzw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yzww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzww();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yzwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzwx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yzwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzwy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yzwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzwz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_yzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yzx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yzxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzxw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yzxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzxx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yzxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzxy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yzxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzxz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_yzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yzy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yzyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzyw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yzyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzyx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yzyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzyy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yzyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzyz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_yzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.yzz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yzzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzzw();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yzzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzzx();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yzzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzzy();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_yzzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.yzzz();
  assert_eq!(v_swizzled.x(), v.y());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.zw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
}
#[test]
fn Vec4_zww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zww();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zwww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwww();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zwwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwwx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zwwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwwy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zwwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwwz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zwx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zwxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwxw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zwxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwxx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zwxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwxy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zwxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwxz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zwy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zwyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwyw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zwyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwyx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zwyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwyy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zwyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwyz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zwz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zwzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwzw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zwzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwzx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zwzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwzy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zwzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zwzz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.w());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.zx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
}
#[test]
fn Vec4_zxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zxw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zxww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxww();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zxwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxwx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zxwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxwy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zxwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxwz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zxx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zxxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxxw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zxxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxxx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zxxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxxy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zxxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxxz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zxy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zxyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxyw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zxyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxyx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zxyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxyy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zxyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxyz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zxz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zxzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxzw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zxzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxzx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zxzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxzy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zxzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zxzz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.x());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.zy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
}
#[test]
fn Vec4_zyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zyw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zyww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyww();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zywx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zywx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zywy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zywy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zywz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zywz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zyx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zyxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyxw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zyxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyxx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zyxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyxy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zyxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyxz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zyy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zyyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyyw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zyyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyyx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zyyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyyy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zyyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyyz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zyz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zyzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyzw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zyzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyzx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zyzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyzy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zyzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zyzz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.y());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec2 = v.zz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
}
#[test]
fn Vec4_zzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zzw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zzww() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzww();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zzwx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzwx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zzwy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzwy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zzwz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzwz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.w());
  assert_eq!(v_swizzled.z(), v.w());
}
#[test]
fn Vec4_zzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zzx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zzxw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzxw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zzxx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzxx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zzxy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzxy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zzxz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzxz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.x());
  assert_eq!(v_swizzled.z(), v.x());
}
#[test]
fn Vec4_zzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zzy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zzyw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzyw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zzyx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzyx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zzyy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzyy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zzyz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzyz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.y());
  assert_eq!(v_swizzled.z(), v.y());
}
#[test]
fn Vec4_zzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec3 = v.zzz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zzzw() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzzw();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zzzx() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzzx();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zzzy() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzzy();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}
#[test]
fn Vec4_zzzz() {
  let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
  let v_swizzled: Vec4 = v.zzzz();
  assert_eq!(v_swizzled.x(), v.z());
  assert_eq!(v_swizzled.y(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
  assert_eq!(v_swizzled.z(), v.z());
}