Vec256b z0; // low half

Vec256b z1; // high half

// Default constructor:

Vec512b() {

}

// Constructor to build from two Vec256b:

Vec512b(Vec256b const & a0, Vec256b const & a1) {

z0 = a0; z1 = a1;

}

// Member function to load from array (unaligned)

Vec512b & load(void const * p) {

z0 = Vec8i().load(p);

z1 = Vec8i().load((int32_t const*)p+8);

return *this;

}

// Member function to load from array, aligned by 64

Vec512b & load_a(void const * p) {

z0 = Vec8i().load_a(p);

z1 = Vec8i().load_a((int32_t const*)p+8);

return *this;

}

// Member function to store into array (unaligned)

void store(void * p) const {

Vec8i(z0).store(p);

Vec8i(z1).store((int32_t*)p+8);

}

// Member function to store into array, aligned by 64

void store_a(void * p) const {

Vec8i(z0).store_a(p);

Vec8i(z1).store_a((int32_t*)p+8);

}

Vec256b get_low() const { // get low half

return z0;

}

Vec256b get_high() const { // get high half

return z1;

}

// Member function to change a single bit

// DEPRECATED

Vec512b const & set_bit(int index, int value) {

if (index < 256) {

z0 = Vec8i(z0).set_bit(index, value);

}

else {

z1 = Vec8i(z1).set_bit(index-256, value);

}

return *this;

}

// Member function to get a single bit

// DEPRECATED

int get_bit(int index) const {

if (index < 256) {

return Vec8i(z0).get_bit(index);

}

else {

return Vec8i(z1).get_bit(index-256);

}

}

// Extract a single element. Use store function if extracting more than one element.

// DEPRECATED

bool operator [] (int index) const {

return get_bit(index) != 0;

}

static int size () {

return 512;

}

static const union {

int32_t i[16];

Vec256b y[2]; // note: requires C++0x or later. Use option -std=c++0x

} u = {{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15}};

return Vec512b(u.y[0], u.y[1]);

static const union {

uint32_t i[16];

Vec256b y[2]; // note: requires C++0x or later. Use option -std=c++0x

} u = {{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15}};

return Vec512b(u.y[0], u.y[1]);

// Default constructor:

Vec16b () {

}

// Constructor to build from all elements:

Vec16b(bool b0, bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7,

bool b8, bool b9, bool b10, bool b11, bool b12, bool b13, bool b14, bool b15) {

*this = Vec512b(Vec8i(-(int)b0, -(int)b1, -(int)b2, -(int)b3, -(int)b4, -(int)b5, -(int)b6, -(int)b7), Vec8i(-(int)b8, -(int)b9, -(int)b10, -(int)b11, -(int)b12, -(int)b13, -(int)b14, -(int)b15));

}

// Constructor to convert from type Vec512b

Vec16b (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Constructor to make from two halves

Vec16b (Vec8ib const & x0, Vec8ib const & x1) {

z0 = x0;

z1 = x1;

}

// Constructor to make from two halves

Vec16b (Vec8i const & x0, Vec8i const & x1) {

z0 = x0;

z1 = x1;

}

// Constructor to broadcast single value:

Vec16b(bool b) {

z0 = z1 = Vec8i(-int32_t(b));

}

// Assignment operator to broadcast scalar value:

Vec16b & operator = (bool b) {

z0 = z1 = Vec8i(-int32_t(b));

return *this;

}

// split into two halves

Vec8ib get_low() const {

return Vec8ib(z0);

}

Vec8ib get_high() const {

return Vec8ib(z1);

}

// Assignment operator to convert from type Vec512b

Vec16b & operator = (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

return *this;

}

// Member function to change a single element in vector

// Note: This function is inefficient. Use load function if changing more than one element

Vec16b const & insert(int index, bool value) {

if ((uint32_t)index < 8) {

z0 = Vec8ib(z0).insert(index, value);

}

else {

z1 = Vec8ib(z1).insert(index-8, value);

}

return *this;

}

// Member function extract a single element from vector

bool extract(int index) const {

if ((uint32_t)index < 8) {

return Vec8ib(z0).extract(index);

}

else {

return Vec8ib(z1).extract(index-8);

}

}

// Extract a single element. Operator [] can only read an element, not write.

bool operator [] (int index) const {

return extract(index);

}

static int size () {

return 16;

}

static int elementtype() {

return 3;

}

private:

// Prevent constructing from int, etc. because of ambiguity

Vec16b(int b);

// Prevent assigning int because of ambiguity

Vec16b & operator = (int x);

// Default constructor:

Vec16ib () {

}

Vec16ib (Vec16b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Constructor to build from all elements:

Vec16ib(bool x0, bool x1, bool x2, bool x3, bool x4, bool x5, bool x6, bool x7,

bool x8, bool x9, bool x10, bool x11, bool x12, bool x13, bool x14, bool x15) {

z0 = Vec8ib(x0, x1, x2, x3, x4, x5, x6, x7);

z1 = Vec8ib(x8, x9, x10, x11, x12, x13, x14, x15);

}

// Constructor to convert from type Vec512b

Vec16ib (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Construct from two halves

Vec16ib (Vec8ib const & x0, Vec8ib const & x1) {

z0 = x0;

z1 = x1;

}

// Assignment operator to convert from type Vec512b

Vec16ib & operator = (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

return *this;

}

// Constructor to broadcast scalar value:

Vec16ib(bool b) : Vec16b(b) {

}

// Assignment operator to broadcast scalar value:

Vec16ib & operator = (bool b) {

*this = Vec16b(b);

return *this;

}

// Member function to change a bitfield to a boolean vector

Vec16ib & load_bits(uint16_t a) {

z0 = Vec8ib().load_bits(uint8_t(a));

z1 = Vec8ib().load_bits(uint8_t(a>>8));

return *this;

}

private: // Prevent constructing from int, etc.

Vec16ib(int b);

Vec16ib & operator = (int x);

// Default constructor:

Vec8b () {

}

Vec8b (Vec16b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Constructor to convert from type Vec512b

Vec8b (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// construct from two halves

Vec8b (Vec4qb const & x0, Vec4qb const & x1) {

z0 = x0;

z1 = x1;

}

// Constructor to broadcast single value:

Vec8b(bool b) {

z0 = z1 = Vec8i(-int32_t(b));

}

// Assignment operator to broadcast scalar value:

Vec8b & operator = (bool b) {

z0 = z1 = Vec8i(-int32_t(b));

return *this;

}

// split into two halves

Vec4qb get_low() const {

return Vec4qb(z0);

}

Vec4qb get_high() const {

return Vec4qb(z1);

}

// Assignment operator to convert from type Vec512b

Vec8b & operator = (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

return *this;

}

// Member function to change a single element in vector

// Note: This function is inefficient. Use load function if changing more than one element

Vec8b const & insert(int index, bool value) {

if ((uint32_t)index < 4) {

z0 = Vec4qb(z0).insert(index, value);

}

else {

z1 = Vec4qb(z1).insert(index-4, value);

}

return *this;

}

bool extract(int index) const {

if ((uint32_t)index < 4) {

return Vec4qb(Vec4q(z0)).extract(index);

}

else {

return Vec4qb(Vec4q(z1)).extract(index-4);

}

}

bool operator [] (int index) const {

return extract(index);

}

static int size () {

return 8;

}

private:

// Prevent constructing from int, etc. because of ambiguity

Vec8b(int b);

// Prevent assigning int because of ambiguity

Vec8b & operator = (int x);

// Default constructor:

Vec8qb () {

}

Vec8qb (Vec16b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Constructor to build from all elements:

Vec8qb(bool x0, bool x1, bool x2, bool x3, bool x4, bool x5, bool x6, bool x7) {

z0 = Vec4qb(x0, x1, x2, x3);

z1 = Vec4qb(x4, x5, x6, x7);

}

// Constructor to convert from type Vec512b

Vec8qb (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// construct from two halves

Vec8qb (Vec4qb const & x0, Vec4qb const & x1) {

z0 = x0;

z1 = x1;

}

// Assignment operator to convert from type Vec512b

Vec8qb & operator = (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

return *this;

}

// Constructor to broadcast single value:

Vec8qb(bool b) : Vec8b(b) {

}

// Assignment operator to broadcast scalar value:

Vec8qb & operator = (bool b) {

*this = Vec8b(b);

return *this;

}

// Member function to change a bitfield to a boolean vector

Vec8qb & load_bits(uint8_t a) {

z0 = Vec4qb().load_bits(a);

z1 = Vec4qb().load_bits(uint8_t(a>>4u));

return *this;

}

private:

// Prevent constructing from int, etc. because of ambiguity

Vec8qb(int b);

// Prevent assigning int because of ambiguity

Vec8qb & operator = (int x);

// Default constructor:

Vec16i() {

}

// Constructor to broadcast the same value into all elements:

Vec16i(int i) {

z0 = z1 = Vec8i(i);

}

// Constructor to build from all elements:

Vec16i(int32_t i0, int32_t i1, int32_t i2, int32_t i3, int32_t i4, int32_t i5, int32_t i6, int32_t i7,

int32_t i8, int32_t i9, int32_t i10, int32_t i11, int32_t i12, int32_t i13, int32_t i14, int32_t i15) {

z0 = Vec8i(i0, i1, i2, i3, i4, i5, i6, i7);

z1 = Vec8i(i8, i9, i10, i11, i12, i13, i14, i15);

}

// Constructor to build from two Vec8i:

Vec16i(Vec8i const & a0, Vec8i const & a1) {

*this = Vec512b(a0, a1);

}

// Constructor to convert from type Vec512b

Vec16i(Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

}

// Assignment operator to convert from type Vec512b

Vec16i & operator = (Vec512b const & x) {

z0 = x.get_low();

z1 = x.get_high();

return *this;

}

// Member function to load from array (unaligned)

Vec16i & load(void const * p) {

Vec512b::load(p);

return *this;

}

// Member function to load from array, aligned by 64

Vec16i & load_a(void const * p) {

Vec512b::load_a(p);

return *this;

}

// Partial load. Load n elements and set the rest to 0

Vec16i & load_partial(int n, void const * p) {

if (n < 8) {

z0 = Vec8i().load_partial(n, p);

z1 = Vec8i(0);

}

else {

z0 = Vec8i().load(p);

z1 = Vec8i().load_partial(n - 8, (int32_t const*)p + 8);

}

return *this;

}

// Partial store. Store n elements

void store_partial(int n, void * p) const {

if (n < 8) {

Vec8i(get_low()).store_partial(n, p);

}

else {

Vec8i(get_low()).store(p);

Vec8i(get_high()).store_partial(n - 8, (int32_t *)p + 8);

}

}

// cut off vector to n elements. The last 8-n elements are set to zero

Vec16i & cutoff(int n) {

if (n < 8) {

z0 = Vec8i(z0).cutoff(n);

z1 = Vec8i(0);

}

else {

z1 = Vec8i(z1).cutoff(n - 8);

}

return *this;

}

// Member function to change a single element in vector

Vec16i const & insert(int index, int32_t value) {

if ((uint32_t)index < 8) {

z0 = Vec8i(z0).insert(index, value);

}

else {

z1 = Vec8i(z1).insert(index - 8, value);

}

return *this;

}

// Member function extract a single element from vector

int32_t extract(int index) const {

if ((uint32_t)index < 8) {

return Vec8i(z0).extract(index);

}

else {

return Vec8i(z1).extract(index - 8);

}

}

// Extract a single element. Use store function if extracting more than one element.

// Operator [] can only read an element, not write.

int32_t operator [] (int index) const {

return extract(index);

}

// Member functions to split into two Vec8i:

Vec8i get_low() const {

return Vec8i(z0);

}

Vec8i get_high() const {

return Vec8i(z1);

}

static int size () {

return 16;

}

static int elementtype() {

return 8;

}