obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1352 insertions, 0 deletions

diff --git a/gcc/testsuite/gcc.dg/vmx/5-10.c b/gcc/testsuite/gcc.dg/vmx/5-10.c
new file mode 100644
index 000000000..5f1b6ddc1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vmx/5-10.c
@@ -0,0 +1,1352 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void fu32a(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0,0,0,0});
+  *u32++ = ((vector unsigned int){1,1,1,1});
+  *u32++ = ((vector unsigned int){2,2,2,2});
+  *u32++ = ((vector unsigned int){3,3,3,3});
+  *u32++ = ((vector unsigned int){4,4,4,4});
+  *u32++ = ((vector unsigned int){5,5,5,5});
+  *u32++ = ((vector unsigned int){6,6,6,6});
+  *u32++ = ((vector unsigned int){7,7,7,7});
+  *u32++ = ((vector unsigned int){8,8,8,8});
+  *u32++ = ((vector unsigned int){9,9,9,9});
+  *u32++ = ((vector unsigned int){10,10,10,10});
+  *u32++ = ((vector unsigned int){11,11,11,11});
+  *u32++ = ((vector unsigned int){12,12,12,12});
+  *u32++ = ((vector unsigned int){13,13,13,13});
+  *u32++ = ((vector unsigned int){14,14,14,14});
+  *u32++ = ((vector unsigned int){15,15,15,15});
+}
+void fu32b(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){65537,65537,65537,65537});
+  *u32++ = ((vector unsigned int){131074,131074,131074,131074});
+  *u32++ = ((vector unsigned int){196611,196611,196611,196611});
+  *u32++ = ((vector unsigned int){262148,262148,262148,262148});
+  *u32++ = ((vector unsigned int){327685,327685,327685,327685});
+  *u32++ = ((vector unsigned int){393222,393222,393222,393222});
+  *u32++ = ((vector unsigned int){458759,458759,458759,458759});
+  *u32++ = ((vector unsigned int){524296,524296,524296,524296});
+  *u32++ = ((vector unsigned int){589833,589833,589833,589833});
+  *u32++ = ((vector unsigned int){655370,655370,655370,655370});
+  *u32++ = ((vector unsigned int){720907,720907,720907,720907});
+  *u32++ = ((vector unsigned int){786444,786444,786444,786444});
+  *u32++ = ((vector unsigned int){851981,851981,851981,851981});
+  *u32++ = ((vector unsigned int){917518,917518,917518,917518});
+  *u32++ = ((vector unsigned int){983055,983055,983055,983055});
+}
+void fu32c(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){16843009,16843009,16843009,16843009});
+  *u32++ = ((vector unsigned int){33686018,33686018,33686018,33686018});
+  *u32++ = ((vector unsigned int){50529027,50529027,50529027,50529027});
+  *u32++ = ((vector unsigned int){67372036,67372036,67372036,67372036});
+  *u32++ = ((vector unsigned int){84215045,84215045,84215045,84215045});
+  *u32++ = ((vector unsigned int){101058054,101058054,101058054,101058054});
+  *u32++ = ((vector unsigned int){117901063,117901063,117901063,117901063});
+  *u32++ = ((vector unsigned int){134744072,134744072,134744072,134744072});
+  *u32++ = ((vector unsigned int){151587081,151587081,151587081,151587081});
+  *u32++ = ((vector unsigned int){168430090,168430090,168430090,168430090});
+  *u32++ = ((vector unsigned int){185273099,185273099,185273099,185273099});
+  *u32++ = ((vector unsigned int){202116108,202116108,202116108,202116108});
+  *u32++ = ((vector unsigned int){218959117,218959117,218959117,218959117});
+  *u32++ = ((vector unsigned int){235802126,235802126,235802126,235802126});
+  *u32++ = ((vector unsigned int){252645135,252645135,252645135,252645135});
+}
+void fu32d(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4042322160,4042322160,4042322160,4042322160});
+  *u32++ = ((vector unsigned int){4059165169,4059165169,4059165169,4059165169});
+  *u32++ = ((vector unsigned int){4076008178,4076008178,4076008178,4076008178});
+  *u32++ = ((vector unsigned int){4092851187,4092851187,4092851187,4092851187});
+  *u32++ = ((vector unsigned int){4109694196,4109694196,4109694196,4109694196});
+  *u32++ = ((vector unsigned int){4126537205,4126537205,4126537205,4126537205});
+  *u32++ = ((vector unsigned int){4143380214,4143380214,4143380214,4143380214});
+  *u32++ = ((vector unsigned int){4160223223,4160223223,4160223223,4160223223});
+  *u32++ = ((vector unsigned int){4177066232,4177066232,4177066232,4177066232});
+  *u32++ = ((vector unsigned int){4193909241,4193909241,4193909241,4193909241});
+  *u32++ = ((vector unsigned int){4210752250,4210752250,4210752250,4210752250});
+  *u32++ = ((vector unsigned int){4227595259,4227595259,4227595259,4227595259});
+  *u32++ = ((vector unsigned int){4244438268,4244438268,4244438268,4244438268});
+  *u32++ = ((vector unsigned int){4261281277,4261281277,4261281277,4261281277});
+  *u32++ = ((vector unsigned int){4278124286,4278124286,4278124286,4278124286});
+}
+void fu32e(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4293984240,4293984240,4293984240,4293984240});
+  *u32++ = ((vector unsigned int){4294049777,4294049777,4294049777,4294049777});
+  *u32++ = ((vector unsigned int){4294115314,4294115314,4294115314,4294115314});
+  *u32++ = ((vector unsigned int){4294180851,4294180851,4294180851,4294180851});
+  *u32++ = ((vector unsigned int){4294246388,4294246388,4294246388,4294246388});
+  *u32++ = ((vector unsigned int){4294311925,4294311925,4294311925,4294311925});
+  *u32++ = ((vector unsigned int){4294377462,4294377462,4294377462,4294377462});
+  *u32++ = ((vector unsigned int){4294442999,4294442999,4294442999,4294442999});
+  *u32++ = ((vector unsigned int){4294508536,4294508536,4294508536,4294508536});
+  *u32++ = ((vector unsigned int){4294574073,4294574073,4294574073,4294574073});
+  *u32++ = ((vector unsigned int){4294639610,4294639610,4294639610,4294639610});
+  *u32++ = ((vector unsigned int){4294705147,4294705147,4294705147,4294705147});
+  *u32++ = ((vector unsigned int){4294770684,4294770684,4294770684,4294770684});
+  *u32++ = ((vector unsigned int){4294836221,4294836221,4294836221,4294836221});
+  *u32++ = ((vector unsigned int){4294901758,4294901758,4294901758,4294901758});
+}
+void fu32f(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4294967280,4294967280,4294967280,4294967280});
+  *u32++ = ((vector unsigned int){4294967281,4294967281,4294967281,4294967281});
+  *u32++ = ((vector unsigned int){4294967282,4294967282,4294967282,4294967282});
+  *u32++ = ((vector unsigned int){4294967283,4294967283,4294967283,4294967283});
+  *u32++ = ((vector unsigned int){4294967284,4294967284,4294967284,4294967284});
+  *u32++ = ((vector unsigned int){4294967285,4294967285,4294967285,4294967285});
+  *u32++ = ((vector unsigned int){4294967286,4294967286,4294967286,4294967286});
+  *u32++ = ((vector unsigned int){4294967287,4294967287,4294967287,4294967287});
+  *u32++ = ((vector unsigned int){4294967288,4294967288,4294967288,4294967288});
+  *u32++ = ((vector unsigned int){4294967289,4294967289,4294967289,4294967289});
+  *u32++ = ((vector unsigned int){4294967290,4294967290,4294967290,4294967290});
+  *u32++ = ((vector unsigned int){4294967291,4294967291,4294967291,4294967291});
+  *u32++ = ((vector unsigned int){4294967292,4294967292,4294967292,4294967292});
+  *u32++ = ((vector unsigned int){4294967293,4294967293,4294967293,4294967293});
+  *u32++ = ((vector unsigned int){4294967294,4294967294,4294967294,4294967294});
+  *u32++ = ((vector unsigned int){4294967295,4294967295,4294967295,4294967295});
+}
+void fu32g(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-252645136,-252645136,-252645136,-252645136});
+  *u32++ = ((vector unsigned int){-235802127,-235802127,-235802127,-235802127});
+  *u32++ = ((vector unsigned int){-218959118,-218959118,-218959118,-218959118});
+  *u32++ = ((vector unsigned int){-202116109,-202116109,-202116109,-202116109});
+  *u32++ = ((vector unsigned int){-185273100,-185273100,-185273100,-185273100});
+  *u32++ = ((vector unsigned int){-168430091,-168430091,-168430091,-168430091});
+  *u32++ = ((vector unsigned int){-151587082,-151587082,-151587082,-151587082});
+  *u32++ = ((vector unsigned int){-134744073,-134744073,-134744073,-134744073});
+  *u32++ = ((vector unsigned int){-117901064,-117901064,-117901064,-117901064});
+  *u32++ = ((vector unsigned int){-101058055,-101058055,-101058055,-101058055});
+  *u32++ = ((vector unsigned int){-84215046,-84215046,-84215046,-84215046});
+  *u32++ = ((vector unsigned int){-67372037,-67372037,-67372037,-67372037});
+  *u32++ = ((vector unsigned int){-50529028,-50529028,-50529028,-50529028});
+  *u32++ = ((vector unsigned int){-33686019,-33686019,-33686019,-33686019});
+  *u32++ = ((vector unsigned int){-16843010,-16843010,-16843010,-16843010});
+}
+void fu32h(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-983056,-983056,-983056,-983056});
+  *u32++ = ((vector unsigned int){-917519,-917519,-917519,-917519});
+  *u32++ = ((vector unsigned int){-851982,-851982,-851982,-851982});
+  *u32++ = ((vector unsigned int){-786445,-786445,-786445,-786445});
+  *u32++ = ((vector unsigned int){-720908,-720908,-720908,-720908});
+  *u32++ = ((vector unsigned int){-655371,-655371,-655371,-655371});
+  *u32++ = ((vector unsigned int){-589834,-589834,-589834,-589834});
+  *u32++ = ((vector unsigned int){-524297,-524297,-524297,-524297});
+  *u32++ = ((vector unsigned int){-458760,-458760,-458760,-458760});
+  *u32++ = ((vector unsigned int){-393223,-393223,-393223,-393223});
+  *u32++ = ((vector unsigned int){-327686,-327686,-327686,-327686});
+  *u32++ = ((vector unsigned int){-262149,-262149,-262149,-262149});
+  *u32++ = ((vector unsigned int){-196612,-196612,-196612,-196612});
+  *u32++ = ((vector unsigned int){-131075,-131075,-131075,-131075});
+  *u32++ = ((vector unsigned int){-65538,-65538,-65538,-65538});
+}
+void fu32i(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-16,-16,-16,-16});
+  *u32++ = ((vector unsigned int){-15,-15,-15,-15});
+  *u32++ = ((vector unsigned int){-14,-14,-14,-14});
+  *u32++ = ((vector unsigned int){-13,-13,-13,-13});
+  *u32++ = ((vector unsigned int){-12,-12,-12,-12});
+  *u32++ = ((vector unsigned int){-11,-11,-11,-11});
+  *u32++ = ((vector unsigned int){-10,-10,-10,-10});
+  *u32++ = ((vector unsigned int){-9,-9,-9,-9});
+  *u32++ = ((vector unsigned int){-8,-8,-8,-8});
+  *u32++ = ((vector unsigned int){-7,-7,-7,-7});
+  *u32++ = ((vector unsigned int){-6,-6,-6,-6});
+  *u32++ = ((vector unsigned int){-5,-5,-5,-5});
+  *u32++ = ((vector unsigned int){-4,-4,-4,-4});
+  *u32++ = ((vector unsigned int){-3,-3,-3,-3});
+  *u32++ = ((vector unsigned int){-2,-2,-2,-2});
+  *u32++ = ((vector unsigned int){-1,-1,-1,-1});
+}
+void fu32j(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xfffffff0,0xfffffff0,0xfffffff0,0xfffffff0});
+  *u32++ = ((vector unsigned int){0xfffffff1,0xfffffff1,0xfffffff1,0xfffffff1});
+  *u32++ = ((vector unsigned int){0xfffffff2,0xfffffff2,0xfffffff2,0xfffffff2});
+  *u32++ = ((vector unsigned int){0xfffffff3,0xfffffff3,0xfffffff3,0xfffffff3});
+  *u32++ = ((vector unsigned int){0xfffffff4,0xfffffff4,0xfffffff4,0xfffffff4});
+  *u32++ = ((vector unsigned int){0xfffffff5,0xfffffff5,0xfffffff5,0xfffffff5});
+  *u32++ = ((vector unsigned int){0xfffffff6,0xfffffff6,0xfffffff6,0xfffffff6});
+  *u32++ = ((vector unsigned int){0xfffffff7,0xfffffff7,0xfffffff7,0xfffffff7});
+  *u32++ = ((vector unsigned int){0xfffffff8,0xfffffff8,0xfffffff8,0xfffffff8});
+  *u32++ = ((vector unsigned int){0xfffffff9,0xfffffff9,0xfffffff9,0xfffffff9});
+  *u32++ = ((vector unsigned int){0xfffffffa,0xfffffffa,0xfffffffa,0xfffffffa});
+  *u32++ = ((vector unsigned int){0xfffffffb,0xfffffffb,0xfffffffb,0xfffffffb});
+  *u32++ = ((vector unsigned int){0xfffffffc,0xfffffffc,0xfffffffc,0xfffffffc});
+  *u32++ = ((vector unsigned int){0xfffffffd,0xfffffffd,0xfffffffd,0xfffffffd});
+  *u32++ = ((vector unsigned int){0xfffffffe,0xfffffffe,0xfffffffe,0xfffffffe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32k(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x00000001,0x00000001,0x00000001,0x00000001});
+  *u32++ = ((vector unsigned int){0x00000002,0x00000002,0x00000002,0x00000002});
+  *u32++ = ((vector unsigned int){0x00000003,0x00000003,0x00000003,0x00000003});
+  *u32++ = ((vector unsigned int){0x00000004,0x00000004,0x00000004,0x00000004});
+  *u32++ = ((vector unsigned int){0x00000005,0x00000005,0x00000005,0x00000005});
+  *u32++ = ((vector unsigned int){0x00000006,0x00000006,0x00000006,0x00000006});
+  *u32++ = ((vector unsigned int){0x00000007,0x00000007,0x00000007,0x00000007});
+  *u32++ = ((vector unsigned int){0x00000008,0x00000008,0x00000008,0x00000008});
+  *u32++ = ((vector unsigned int){0x00000009,0x00000009,0x00000009,0x00000009});
+  *u32++ = ((vector unsigned int){0x0000000a,0x0000000a,0x0000000a,0x0000000a});
+  *u32++ = ((vector unsigned int){0x0000000b,0x0000000b,0x0000000b,0x0000000b});
+  *u32++ = ((vector unsigned int){0x0000000c,0x0000000c,0x0000000c,0x0000000c});
+  *u32++ = ((vector unsigned int){0x0000000d,0x0000000d,0x0000000d,0x0000000d});
+  *u32++ = ((vector unsigned int){0x0000000e,0x0000000e,0x0000000e,0x0000000e});
+  *u32++ = ((vector unsigned int){0x0000000f,0x0000000f,0x0000000f,0x0000000f});
+}
+void fu32l(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xfff0fff0,0xfff0fff0,0xfff0fff0,0xfff0fff0});
+  *u32++ = ((vector unsigned int){0xfff1fff1,0xfff1fff1,0xfff1fff1,0xfff1fff1});
+  *u32++ = ((vector unsigned int){0xfff2fff2,0xfff2fff2,0xfff2fff2,0xfff2fff2});
+  *u32++ = ((vector unsigned int){0xfff3fff3,0xfff3fff3,0xfff3fff3,0xfff3fff3});
+  *u32++ = ((vector unsigned int){0xfff4fff4,0xfff4fff4,0xfff4fff4,0xfff4fff4});
+  *u32++ = ((vector unsigned int){0xfff5fff5,0xfff5fff5,0xfff5fff5,0xfff5fff5});
+  *u32++ = ((vector unsigned int){0xfff6fff6,0xfff6fff6,0xfff6fff6,0xfff6fff6});
+  *u32++ = ((vector unsigned int){0xfff7fff7,0xfff7fff7,0xfff7fff7,0xfff7fff7});
+  *u32++ = ((vector unsigned int){0xfff8fff8,0xfff8fff8,0xfff8fff8,0xfff8fff8});
+  *u32++ = ((vector unsigned int){0xfff9fff9,0xfff9fff9,0xfff9fff9,0xfff9fff9});
+  *u32++ = ((vector unsigned int){0xfffafffa,0xfffafffa,0xfffafffa,0xfffafffa});
+  *u32++ = ((vector unsigned int){0xfffbfffb,0xfffbfffb,0xfffbfffb,0xfffbfffb});
+  *u32++ = ((vector unsigned int){0xfffcfffc,0xfffcfffc,0xfffcfffc,0xfffcfffc});
+  *u32++ = ((vector unsigned int){0xfffdfffd,0xfffdfffd,0xfffdfffd,0xfffdfffd});
+  *u32++ = ((vector unsigned int){0xfffefffe,0xfffefffe,0xfffefffe,0xfffefffe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32m(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x00010001,0x00010001,0x00010001,0x00010001});
+  *u32++ = ((vector unsigned int){0x00020002,0x00020002,0x00020002,0x00020002});
+  *u32++ = ((vector unsigned int){0x00030003,0x00030003,0x00030003,0x00030003});
+  *u32++ = ((vector unsigned int){0x00040004,0x00040004,0x00040004,0x00040004});
+  *u32++ = ((vector unsigned int){0x00050005,0x00050005,0x00050005,0x00050005});
+  *u32++ = ((vector unsigned int){0x00060006,0x00060006,0x00060006,0x00060006});
+  *u32++ = ((vector unsigned int){0x00070007,0x00070007,0x00070007,0x00070007});
+  *u32++ = ((vector unsigned int){0x00080008,0x00080008,0x00080008,0x00080008});
+  *u32++ = ((vector unsigned int){0x00090009,0x00090009,0x00090009,0x00090009});
+  *u32++ = ((vector unsigned int){0x000a000a,0x000a000a,0x000a000a,0x000a000a});
+  *u32++ = ((vector unsigned int){0x000b000b,0x000b000b,0x000b000b,0x000b000b});
+  *u32++ = ((vector unsigned int){0x000c000c,0x000c000c,0x000c000c,0x000c000c});
+  *u32++ = ((vector unsigned int){0x000d000d,0x000d000d,0x000d000d,0x000d000d});
+  *u32++ = ((vector unsigned int){0x000e000e,0x000e000e,0x000e000e,0x000e000e});
+  *u32++ = ((vector unsigned int){0x000f000f,0x000f000f,0x000f000f,0x000f000f});
+}
+void fu32n(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0});
+  *u32++ = ((vector unsigned int){0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1});
+  *u32++ = ((vector unsigned int){0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2});
+  *u32++ = ((vector unsigned int){0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3});
+  *u32++ = ((vector unsigned int){0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4});
+  *u32++ = ((vector unsigned int){0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5});
+  *u32++ = ((vector unsigned int){0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6});
+  *u32++ = ((vector unsigned int){0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7});
+  *u32++ = ((vector unsigned int){0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8});
+  *u32++ = ((vector unsigned int){0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9});
+  *u32++ = ((vector unsigned int){0xfafafafa,0xfafafafa,0xfafafafa,0xfafafafa});
+  *u32++ = ((vector unsigned int){0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb});
+  *u32++ = ((vector unsigned int){0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc});
+  *u32++ = ((vector unsigned int){0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd});
+  *u32++ = ((vector unsigned int){0xfefefefe,0xfefefefe,0xfefefefe,0xfefefefe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32o(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x01010101,0x01010101,0x01010101,0x01010101});
+  *u32++ = ((vector unsigned int){0x02020202,0x02020202,0x02020202,0x02020202});
+  *u32++ = ((vector unsigned int){0x03030303,0x03030303,0x03030303,0x03030303});
+  *u32++ = ((vector unsigned int){0x04040404,0x04040404,0x04040404,0x04040404});
+  *u32++ = ((vector unsigned int){0x05050505,0x05050505,0x05050505,0x05050505});
+  *u32++ = ((vector unsigned int){0x06060606,0x06060606,0x06060606,0x06060606});
+  *u32++ = ((vector unsigned int){0x07070707,0x07070707,0x07070707,0x07070707});
+  *u32++ = ((vector unsigned int){0x08080808,0x08080808,0x08080808,0x08080808});
+  *u32++ = ((vector unsigned int){0x09090909,0x09090909,0x09090909,0x09090909});
+  *u32++ = ((vector unsigned int){0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a});
+  *u32++ = ((vector unsigned int){0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b});
+  *u32++ = ((vector unsigned int){0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c});
+  *u32++ = ((vector unsigned int){0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d});
+  *u32++ = ((vector unsigned int){0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e});
+  *u32++ = ((vector unsigned int){0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f});
+}
+void fu16a(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0});
+  *u16++ = ((vector unsigned short){0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1});
+  *u16++ = ((vector unsigned short){0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2});
+  *u16++ = ((vector unsigned short){0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3});
+  *u16++ = ((vector unsigned short){0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4});
+  *u16++ = ((vector unsigned short){0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5});
+  *u16++ = ((vector unsigned short){0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6});
+  *u16++ = ((vector unsigned short){0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7});
+  *u16++ = ((vector unsigned short){0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8});
+  *u16++ = ((vector unsigned short){0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9});
+  *u16++ = ((vector unsigned short){0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa});
+  *u16++ = ((vector unsigned short){0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb});
+  *u16++ = ((vector unsigned short){0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc});
+  *u16++ = ((vector unsigned short){0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd});
+  *u16++ = ((vector unsigned short){0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16b(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001});
+  *u16++ = ((vector unsigned short){0x0000,0x0002,0x0000,0x0002,0x0000,0x0002,0x0000,0x0002});
+  *u16++ = ((vector unsigned short){0x0000,0x0003,0x0000,0x0003,0x0000,0x0003,0x0000,0x0003});
+  *u16++ = ((vector unsigned short){0x0000,0x0004,0x0000,0x0004,0x0000,0x0004,0x0000,0x0004});
+  *u16++ = ((vector unsigned short){0x0000,0x0005,0x0000,0x0005,0x0000,0x0005,0x0000,0x0005});
+  *u16++ = ((vector unsigned short){0x0000,0x0006,0x0000,0x0006,0x0000,0x0006,0x0000,0x0006});
+  *u16++ = ((vector unsigned short){0x0000,0x0007,0x0000,0x0007,0x0000,0x0007,0x0000,0x0007});
+  *u16++ = ((vector unsigned short){0x0000,0x0008,0x0000,0x0008,0x0000,0x0008,0x0000,0x0008});
+  *u16++ = ((vector unsigned short){0x0000,0x0009,0x0000,0x0009,0x0000,0x0009,0x0000,0x0009});
+  *u16++ = ((vector unsigned short){0x0000,0x000a,0x0000,0x000a,0x0000,0x000a,0x0000,0x000a});
+  *u16++ = ((vector unsigned short){0x0000,0x000b,0x0000,0x000b,0x0000,0x000b,0x0000,0x000b});
+  *u16++ = ((vector unsigned short){0x0000,0x000c,0x0000,0x000c,0x0000,0x000c,0x0000,0x000c});
+  *u16++ = ((vector unsigned short){0x0000,0x000d,0x0000,0x000d,0x0000,0x000d,0x0000,0x000d});
+  *u16++ = ((vector unsigned short){0x0000,0x000e,0x0000,0x000e,0x0000,0x000e,0x0000,0x000e});
+  *u16++ = ((vector unsigned short){0x0000,0x000f,0x0000,0x000f,0x0000,0x000f,0x0000,0x000f});
+}
+void fu16c(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0});
+  *u16++ = ((vector unsigned short){0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1});
+  *u16++ = ((vector unsigned short){0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2});
+  *u16++ = ((vector unsigned short){0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3});
+  *u16++ = ((vector unsigned short){0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4});
+  *u16++ = ((vector unsigned short){0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5});
+  *u16++ = ((vector unsigned short){0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6});
+  *u16++ = ((vector unsigned short){0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7});
+  *u16++ = ((vector unsigned short){0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8});
+  *u16++ = ((vector unsigned short){0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9});
+  *u16++ = ((vector unsigned short){0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa});
+  *u16++ = ((vector unsigned short){0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb});
+  *u16++ = ((vector unsigned short){0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc});
+  *u16++ = ((vector unsigned short){0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd});
+  *u16++ = ((vector unsigned short){0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16d(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001});
+  *u16++ = ((vector unsigned short){0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002});
+  *u16++ = ((vector unsigned short){0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003});
+  *u16++ = ((vector unsigned short){0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004});
+  *u16++ = ((vector unsigned short){0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005});
+  *u16++ = ((vector unsigned short){0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006});
+  *u16++ = ((vector unsigned short){0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007});
+  *u16++ = ((vector unsigned short){0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008});
+  *u16++ = ((vector unsigned short){0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009});
+  *u16++ = ((vector unsigned short){0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a});
+  *u16++ = ((vector unsigned short){0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b});
+  *u16++ = ((vector unsigned short){0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c});
+  *u16++ = ((vector unsigned short){0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d});
+  *u16++ = ((vector unsigned short){0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e});
+  *u16++ = ((vector unsigned short){0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f});
+}
+void fu16e(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0});
+  *u16++ = ((vector unsigned short){0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1});
+  *u16++ = ((vector unsigned short){0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2});
+  *u16++ = ((vector unsigned short){0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3});
+  *u16++ = ((vector unsigned short){0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4});
+  *u16++ = ((vector unsigned short){0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5});
+  *u16++ = ((vector unsigned short){0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6});
+  *u16++ = ((vector unsigned short){0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7});
+  *u16++ = ((vector unsigned short){0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8});
+  *u16++ = ((vector unsigned short){0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9});
+  *u16++ = ((vector unsigned short){0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa});
+  *u16++ = ((vector unsigned short){0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb});
+  *u16++ = ((vector unsigned short){0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc});
+  *u16++ = ((vector unsigned short){0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd});
+  *u16++ = ((vector unsigned short){0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16f(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101});
+  *u16++ = ((vector unsigned short){0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202});
+  *u16++ = ((vector unsigned short){0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303});
+  *u16++ = ((vector unsigned short){0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404});
+  *u16++ = ((vector unsigned short){0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505});
+  *u16++ = ((vector unsigned short){0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606});
+  *u16++ = ((vector unsigned short){0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707});
+  *u16++ = ((vector unsigned short){0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808});
+  *u16++ = ((vector unsigned short){0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909});
+  *u16++ = ((vector unsigned short){0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a});
+  *u16++ = ((vector unsigned short){0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b});
+  *u16++ = ((vector unsigned short){0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c});
+  *u16++ = ((vector unsigned short){0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d});
+  *u16++ = ((vector unsigned short){0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e});
+  *u16++ = ((vector unsigned short){0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f});
+}
+void fu16g(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0,0,0,0,0,0,0,0});
+  *u16++ = ((vector unsigned short){1,1,1,1,1,1,1,1});
+  *u16++ = ((vector unsigned short){2,2,2,2,2,2,2,2});
+  *u16++ = ((vector unsigned short){3,3,3,3,3,3,3,3});
+  *u16++ = ((vector unsigned short){4,4,4,4,4,4,4,4});
+  *u16++ = ((vector unsigned short){5,5,5,5,5,5,5,5});
+  *u16++ = ((vector unsigned short){6,6,6,6,6,6,6,6});
+  *u16++ = ((vector unsigned short){7,7,7,7,7,7,7,7});
+  *u16++ = ((vector unsigned short){8,8,8,8,8,8,8,8});
+  *u16++ = ((vector unsigned short){9,9,9,9,9,9,9,9});
+  *u16++ = ((vector unsigned short){10,10,10,10,10,10,10,10});
+  *u16++ = ((vector unsigned short){11,11,11,11,11,11,11,11});
+  *u16++ = ((vector unsigned short){12,12,12,12,12,12,12,12});
+  *u16++ = ((vector unsigned short){13,13,13,13,13,13,13,13});
+  *u16++ = ((vector unsigned short){14,14,14,14,14,14,14,14});
+  *u16++ = ((vector unsigned short){15,15,15,15,15,15,15,15});
+}
+void fu16h(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){257,257,257,257,257,257,257,257});
+  *u16++ = ((vector unsigned short){514,514,514,514,514,514,514,514});
+  *u16++ = ((vector unsigned short){771,771,771,771,771,771,771,771});
+  *u16++ = ((vector unsigned short){1028,1028,1028,1028,1028,1028,1028,1028});
+  *u16++ = ((vector unsigned short){1285,1285,1285,1285,1285,1285,1285,1285});
+  *u16++ = ((vector unsigned short){1542,1542,1542,1542,1542,1542,1542,1542});
+  *u16++ = ((vector unsigned short){1799,1799,1799,1799,1799,1799,1799,1799});
+  *u16++ = ((vector unsigned short){2056,2056,2056,2056,2056,2056,2056,2056});
+  *u16++ = ((vector unsigned short){2313,2313,2313,2313,2313,2313,2313,2313});
+  *u16++ = ((vector unsigned short){2570,2570,2570,2570,2570,2570,2570,2570});
+  *u16++ = ((vector unsigned short){2827,2827,2827,2827,2827,2827,2827,2827});
+  *u16++ = ((vector unsigned short){3084,3084,3084,3084,3084,3084,3084,3084});
+  *u16++ = ((vector unsigned short){3341,3341,3341,3341,3341,3341,3341,3341});
+  *u16++ = ((vector unsigned short){3598,3598,3598,3598,3598,3598,3598,3598});
+  *u16++ = ((vector unsigned short){3855,3855,3855,3855,3855,3855,3855,3855});
+}
+void fu16i(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){61680,61680,61680,61680,61680,61680,61680,61680});
+  *u16++ = ((vector unsigned short){61937,61937,61937,61937,61937,61937,61937,61937});
+  *u16++ = ((vector unsigned short){62194,62194,62194,62194,62194,62194,62194,62194});
+  *u16++ = ((vector unsigned short){62451,62451,62451,62451,62451,62451,62451,62451});
+  *u16++ = ((vector unsigned short){62708,62708,62708,62708,62708,62708,62708,62708});
+  *u16++ = ((vector unsigned short){62965,62965,62965,62965,62965,62965,62965,62965});
+  *u16++ = ((vector unsigned short){63222,63222,63222,63222,63222,63222,63222,63222});
+  *u16++ = ((vector unsigned short){63479,63479,63479,63479,63479,63479,63479,63479});
+  *u16++ = ((vector unsigned short){63736,63736,63736,63736,63736,63736,63736,63736});
+  *u16++ = ((vector unsigned short){63993,63993,63993,63993,63993,63993,63993,63993});
+  *u16++ = ((vector unsigned short){64250,64250,64250,64250,64250,64250,64250,64250});
+  *u16++ = ((vector unsigned short){64507,64507,64507,64507,64507,64507,64507,64507});
+  *u16++ = ((vector unsigned short){64764,64764,64764,64764,64764,64764,64764,64764});
+  *u16++ = ((vector unsigned short){65021,65021,65021,65021,65021,65021,65021,65021});
+  *u16++ = ((vector unsigned short){65278,65278,65278,65278,65278,65278,65278,65278});
+}
+void fu16j(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){65520,65520,65520,65520,65520,65520,65520,65520});
+  *u16++ = ((vector unsigned short){65521,65521,65521,65521,65521,65521,65521,65521});
+  *u16++ = ((vector unsigned short){65522,65522,65522,65522,65522,65522,65522,65522});
+  *u16++ = ((vector unsigned short){65523,65523,65523,65523,65523,65523,65523,65523});
+  *u16++ = ((vector unsigned short){65524,65524,65524,65524,65524,65524,65524,65524});
+  *u16++ = ((vector unsigned short){65525,65525,65525,65525,65525,65525,65525,65525});
+  *u16++ = ((vector unsigned short){65526,65526,65526,65526,65526,65526,65526,65526});
+  *u16++ = ((vector unsigned short){65527,65527,65527,65527,65527,65527,65527,65527});
+  *u16++ = ((vector unsigned short){65528,65528,65528,65528,65528,65528,65528,65528});
+  *u16++ = ((vector unsigned short){65529,65529,65529,65529,65529,65529,65529,65529});
+  *u16++ = ((vector unsigned short){65530,65530,65530,65530,65530,65530,65530,65530});
+  *u16++ = ((vector unsigned short){65531,65531,65531,65531,65531,65531,65531,65531});
+  *u16++ = ((vector unsigned short){65532,65532,65532,65532,65532,65532,65532,65532});
+  *u16++ = ((vector unsigned short){65533,65533,65533,65533,65533,65533,65533,65533});
+  *u16++ = ((vector unsigned short){65534,65534,65534,65534,65534,65534,65534,65534});
+  *u16++ = ((vector unsigned short){65535,65535,65535,65535,65535,65535,65535,65535});
+}
+void fu16k(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){-3856,-3856,-3856,-3856,-3856,-3856,-3856,-3856});
+  *u16++ = ((vector unsigned short){-3599,-3599,-3599,-3599,-3599,-3599,-3599,-3599});
+  *u16++ = ((vector unsigned short){-3342,-3342,-3342,-3342,-3342,-3342,-3342,-3342});
+  *u16++ = ((vector unsigned short){-3085,-3085,-3085,-3085,-3085,-3085,-3085,-3085});
+  *u16++ = ((vector unsigned short){-2828,-2828,-2828,-2828,-2828,-2828,-2828,-2828});
+  *u16++ = ((vector unsigned short){-2571,-2571,-2571,-2571,-2571,-2571,-2571,-2571});
+  *u16++ = ((vector unsigned short){-2314,-2314,-2314,-2314,-2314,-2314,-2314,-2314});
+  *u16++ = ((vector unsigned short){-2057,-2057,-2057,-2057,-2057,-2057,-2057,-2057});
+  *u16++ = ((vector unsigned short){-1800,-1800,-1800,-1800,-1800,-1800,-1800,-1800});
+  *u16++ = ((vector unsigned short){-1543,-1543,-1543,-1543,-1543,-1543,-1543,-1543});
+  *u16++ = ((vector unsigned short){-1286,-1286,-1286,-1286,-1286,-1286,-1286,-1286});
+  *u16++ = ((vector unsigned short){-1029,-1029,-1029,-1029,-1029,-1029,-1029,-1029});
+  *u16++ = ((vector unsigned short){-772,-772,-772,-772,-772,-772,-772,-772});
+  *u16++ = ((vector unsigned short){-515,-515,-515,-515,-515,-515,-515,-515});
+  *u16++ = ((vector unsigned short){-258,-258,-258,-258,-258,-258,-258,-258});
+}
+void fu16l(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){-16,-16,-16,-16,-16,-16,-16,-16});
+  *u16++ = ((vector unsigned short){-15,-15,-15,-15,-15,-15,-15,-15});
+  *u16++ = ((vector unsigned short){-14,-14,-14,-14,-14,-14,-14,-14});
+  *u16++ = ((vector unsigned short){-13,-13,-13,-13,-13,-13,-13,-13});
+  *u16++ = ((vector unsigned short){-12,-12,-12,-12,-12,-12,-12,-12});
+  *u16++ = ((vector unsigned short){-11,-11,-11,-11,-11,-11,-11,-11});
+  *u16++ = ((vector unsigned short){-10,-10,-10,-10,-10,-10,-10,-10});
+  *u16++ = ((vector unsigned short){-9,-9,-9,-9,-9,-9,-9,-9});
+  *u16++ = ((vector unsigned short){-8,-8,-8,-8,-8,-8,-8,-8});
+  *u16++ = ((vector unsigned short){-7,-7,-7,-7,-7,-7,-7,-7});
+  *u16++ = ((vector unsigned short){-6,-6,-6,-6,-6,-6,-6,-6});
+  *u16++ = ((vector unsigned short){-5,-5,-5,-5,-5,-5,-5,-5});
+  *u16++ = ((vector unsigned short){-4,-4,-4,-4,-4,-4,-4,-4});
+  *u16++ = ((vector unsigned short){-3,-3,-3,-3,-3,-3,-3,-3});
+  *u16++ = ((vector unsigned short){-2,-2,-2,-2,-2,-2,-2,-2});
+  *u16++ = ((vector unsigned short){-1,-1,-1,-1,-1,-1,-1,-1});
+}
+void fu8a(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8b(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f});
+}
+void fu8c(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0});
+  *u8++ = ((vector unsigned char){0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1});
+  *u8++ = ((vector unsigned char){0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2});
+  *u8++ = ((vector unsigned char){0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3});
+  *u8++ = ((vector unsigned char){0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4});
+  *u8++ = ((vector unsigned char){0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5});
+  *u8++ = ((vector unsigned char){0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6});
+  *u8++ = ((vector unsigned char){0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7});
+  *u8++ = ((vector unsigned char){0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8});
+  *u8++ = ((vector unsigned char){0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9});
+  *u8++ = ((vector unsigned char){0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa});
+  *u8++ = ((vector unsigned char){0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb});
+  *u8++ = ((vector unsigned char){0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc});
+  *u8++ = ((vector unsigned char){0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd});
+  *u8++ = ((vector unsigned char){0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8d(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01});
+  *u8++ = ((vector unsigned char){0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02});
+  *u8++ = ((vector unsigned char){0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03});
+  *u8++ = ((vector unsigned char){0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04});
+  *u8++ = ((vector unsigned char){0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05});
+  *u8++ = ((vector unsigned char){0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06});
+  *u8++ = ((vector unsigned char){0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07});
+  *u8++ = ((vector unsigned char){0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08});
+  *u8++ = ((vector unsigned char){0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09});
+  *u8++ = ((vector unsigned char){0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a});
+  *u8++ = ((vector unsigned char){0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b});
+  *u8++ = ((vector unsigned char){0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c});
+  *u8++ = ((vector unsigned char){0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d});
+  *u8++ = ((vector unsigned char){0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e});
+  *u8++ = ((vector unsigned char){0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f});
+}
+void fu8e(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01});
+  *u8++ = ((vector unsigned char){0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02});
+  *u8++ = ((vector unsigned char){0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03});
+  *u8++ = ((vector unsigned char){0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04});
+  *u8++ = ((vector unsigned char){0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05});
+  *u8++ = ((vector unsigned char){0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06});
+  *u8++ = ((vector unsigned char){0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07});
+  *u8++ = ((vector unsigned char){0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08});
+  *u8++ = ((vector unsigned char){0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09});
+  *u8++ = ((vector unsigned char){0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a});
+  *u8++ = ((vector unsigned char){0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b});
+  *u8++ = ((vector unsigned char){0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c});
+  *u8++ = ((vector unsigned char){0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d});
+  *u8++ = ((vector unsigned char){0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e});
+  *u8++ = ((vector unsigned char){0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f});
+}
+void fu8f(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0});
+  *u8++ = ((vector unsigned char){0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1});
+  *u8++ = ((vector unsigned char){0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2});
+  *u8++ = ((vector unsigned char){0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3});
+  *u8++ = ((vector unsigned char){0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4});
+  *u8++ = ((vector unsigned char){0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5});
+  *u8++ = ((vector unsigned char){0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6});
+  *u8++ = ((vector unsigned char){0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7});
+  *u8++ = ((vector unsigned char){0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8});
+  *u8++ = ((vector unsigned char){0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9});
+  *u8++ = ((vector unsigned char){0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa});
+  *u8++ = ((vector unsigned char){0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb});
+  *u8++ = ((vector unsigned char){0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc});
+  *u8++ = ((vector unsigned char){0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd});
+  *u8++ = ((vector unsigned char){0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8g(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0});
+  *u8++ = ((vector unsigned char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  *u8++ = ((vector unsigned char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2});
+  *u8++ = ((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  *u8++ = ((vector unsigned char){4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4});
+  *u8++ = ((vector unsigned char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  *u8++ = ((vector unsigned char){6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6});
+  *u8++ = ((vector unsigned char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+  *u8++ = ((vector unsigned char){8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8});
+  *u8++ = ((vector unsigned char){9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9});
+  *u8++ = ((vector unsigned char){10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10});
+  *u8++ = ((vector unsigned char){11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11});
+  *u8++ = ((vector unsigned char){12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12});
+  *u8++ = ((vector unsigned char){13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13});
+  *u8++ = ((vector unsigned char){14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14});
+  *u8++ = ((vector unsigned char){15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15});
+}
+void fu8h(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240});
+  *u8++ = ((vector unsigned char){241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241});
+  *u8++ = ((vector unsigned char){242,242,242,242,242,242,242,242,242,242,242,242,242,242,242,242});
+  *u8++ = ((vector unsigned char){243,243,243,243,243,243,243,243,243,243,243,243,243,243,243,243});
+  *u8++ = ((vector unsigned char){244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244});
+  *u8++ = ((vector unsigned char){245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245});
+  *u8++ = ((vector unsigned char){246,246,246,246,246,246,246,246,246,246,246,246,246,246,246,246});
+  *u8++ = ((vector unsigned char){247,247,247,247,247,247,247,247,247,247,247,247,247,247,247,247});
+  *u8++ = ((vector unsigned char){248,248,248,248,248,248,248,248,248,248,248,248,248,248,248,248});
+  *u8++ = ((vector unsigned char){249,249,249,249,249,249,249,249,249,249,249,249,249,249,249,249});
+  *u8++ = ((vector unsigned char){250,250,250,250,250,250,250,250,250,250,250,250,250,250,250,250});
+  *u8++ = ((vector unsigned char){251,251,251,251,251,251,251,251,251,251,251,251,251,251,251,251});
+  *u8++ = ((vector unsigned char){252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252});
+  *u8++ = ((vector unsigned char){253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253});
+  *u8++ = ((vector unsigned char){254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,254});
+  *u8++ = ((vector unsigned char){255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255});
+}
+void fu8i(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1});
+  *u8++ = ((vector unsigned char){-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2});
+  *u8++ = ((vector unsigned char){-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3});
+  *u8++ = ((vector unsigned char){-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4});
+  *u8++ = ((vector unsigned char){-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5});
+  *u8++ = ((vector unsigned char){-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6});
+  *u8++ = ((vector unsigned char){-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7});
+  *u8++ = ((vector unsigned char){-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8});
+  *u8++ = ((vector unsigned char){-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9});
+  *u8++ = ((vector unsigned char){-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10});
+  *u8++ = ((vector unsigned char){-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11});
+  *u8++ = ((vector unsigned char){-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12});
+  *u8++ = ((vector unsigned char){-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13});
+  *u8++ = ((vector unsigned char){-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14});
+  *u8++ = ((vector unsigned char){-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15});
+  *u8++ = ((vector unsigned char){-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16});
+}
+void fs32a(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0,0,0,0});
+  *s32++ = ((vector signed int){1,1,1,1});
+  *s32++ = ((vector signed int){2,2,2,2});
+  *s32++ = ((vector signed int){3,3,3,3});
+  *s32++ = ((vector signed int){4,4,4,4});
+  *s32++ = ((vector signed int){5,5,5,5});
+  *s32++ = ((vector signed int){6,6,6,6});
+  *s32++ = ((vector signed int){7,7,7,7});
+  *s32++ = ((vector signed int){8,8,8,8});
+  *s32++ = ((vector signed int){9,9,9,9});
+  *s32++ = ((vector signed int){10,10,10,10});
+  *s32++ = ((vector signed int){11,11,11,11});
+  *s32++ = ((vector signed int){12,12,12,12});
+  *s32++ = ((vector signed int){13,13,13,13});
+  *s32++ = ((vector signed int){14,14,14,14});
+  *s32++ = ((vector signed int){15,15,15,15});
+}
+void fs32b(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){65537,65537,65537,65537});
+  *s32++ = ((vector signed int){131074,131074,131074,131074});
+  *s32++ = ((vector signed int){196611,196611,196611,196611});
+  *s32++ = ((vector signed int){262148,262148,262148,262148});
+  *s32++ = ((vector signed int){327685,327685,327685,327685});
+  *s32++ = ((vector signed int){393222,393222,393222,393222});
+  *s32++ = ((vector signed int){458759,458759,458759,458759});
+  *s32++ = ((vector signed int){524296,524296,524296,524296});
+  *s32++ = ((vector signed int){589833,589833,589833,589833});
+  *s32++ = ((vector signed int){655370,655370,655370,655370});
+  *s32++ = ((vector signed int){720907,720907,720907,720907});
+  *s32++ = ((vector signed int){786444,786444,786444,786444});
+  *s32++ = ((vector signed int){851981,851981,851981,851981});
+  *s32++ = ((vector signed int){917518,917518,917518,917518});
+  *s32++ = ((vector signed int){983055,983055,983055,983055});
+}
+void fs32c(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){16843009,16843009,16843009,16843009});
+  *s32++ = ((vector signed int){33686018,33686018,33686018,33686018});
+  *s32++ = ((vector signed int){50529027,50529027,50529027,50529027});
+  *s32++ = ((vector signed int){67372036,67372036,67372036,67372036});
+  *s32++ = ((vector signed int){84215045,84215045,84215045,84215045});
+  *s32++ = ((vector signed int){101058054,101058054,101058054,101058054});
+  *s32++ = ((vector signed int){117901063,117901063,117901063,117901063});
+  *s32++ = ((vector signed int){134744072,134744072,134744072,134744072});
+  *s32++ = ((vector signed int){151587081,151587081,151587081,151587081});
+  *s32++ = ((vector signed int){168430090,168430090,168430090,168430090});
+  *s32++ = ((vector signed int){185273099,185273099,185273099,185273099});
+  *s32++ = ((vector signed int){202116108,202116108,202116108,202116108});
+  *s32++ = ((vector signed int){218959117,218959117,218959117,218959117});
+  *s32++ = ((vector signed int){235802126,235802126,235802126,235802126});
+  *s32++ = ((vector signed int){252645135,252645135,252645135,252645135});
+}
+void fs32d(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4042322160,4042322160,4042322160,4042322160});
+  *s32++ = ((vector signed int){4059165169,4059165169,4059165169,4059165169});
+  *s32++ = ((vector signed int){4076008178,4076008178,4076008178,4076008178});
+  *s32++ = ((vector signed int){4092851187,4092851187,4092851187,4092851187});
+  *s32++ = ((vector signed int){4109694196,4109694196,4109694196,4109694196});
+  *s32++ = ((vector signed int){4126537205,4126537205,4126537205,4126537205});
+  *s32++ = ((vector signed int){4143380214,4143380214,4143380214,4143380214});
+  *s32++ = ((vector signed int){4160223223,4160223223,4160223223,4160223223});
+  *s32++ = ((vector signed int){4177066232,4177066232,4177066232,4177066232});
+  *s32++ = ((vector signed int){4193909241,4193909241,4193909241,4193909241});
+  *s32++ = ((vector signed int){4210752250,4210752250,4210752250,4210752250});
+  *s32++ = ((vector signed int){4227595259,4227595259,4227595259,4227595259});
+  *s32++ = ((vector signed int){4244438268,4244438268,4244438268,4244438268});
+  *s32++ = ((vector signed int){4261281277,4261281277,4261281277,4261281277});
+  *s32++ = ((vector signed int){4278124286,4278124286,4278124286,4278124286});
+}
+void fs32e(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4293984240,4293984240,4293984240,4293984240});
+  *s32++ = ((vector signed int){4294049777,4294049777,4294049777,4294049777});
+  *s32++ = ((vector signed int){4294115314,4294115314,4294115314,4294115314});
+  *s32++ = ((vector signed int){4294180851,4294180851,4294180851,4294180851});
+  *s32++ = ((vector signed int){4294246388,4294246388,4294246388,4294246388});
+  *s32++ = ((vector signed int){4294311925,4294311925,4294311925,4294311925});
+  *s32++ = ((vector signed int){4294377462,4294377462,4294377462,4294377462});
+  *s32++ = ((vector signed int){4294442999,4294442999,4294442999,4294442999});
+  *s32++ = ((vector signed int){4294508536,4294508536,4294508536,4294508536});
+  *s32++ = ((vector signed int){4294574073,4294574073,4294574073,4294574073});
+  *s32++ = ((vector signed int){4294639610,4294639610,4294639610,4294639610});
+  *s32++ = ((vector signed int){4294705147,4294705147,4294705147,4294705147});
+  *s32++ = ((vector signed int){4294770684,4294770684,4294770684,4294770684});
+  *s32++ = ((vector signed int){4294836221,4294836221,4294836221,4294836221});
+  *s32++ = ((vector signed int){4294901758,4294901758,4294901758,4294901758});
+}
+void fs32f(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4294967280,4294967280,4294967280,4294967280});
+  *s32++ = ((vector signed int){4294967281,4294967281,4294967281,4294967281});
+  *s32++ = ((vector signed int){4294967282,4294967282,4294967282,4294967282});
+  *s32++ = ((vector signed int){4294967283,4294967283,4294967283,4294967283});
+  *s32++ = ((vector signed int){4294967284,4294967284,4294967284,4294967284});
+  *s32++ = ((vector signed int){4294967285,4294967285,4294967285,4294967285});
+  *s32++ = ((vector signed int){4294967286,4294967286,4294967286,4294967286});
+  *s32++ = ((vector signed int){4294967287,4294967287,4294967287,4294967287});
+  *s32++ = ((vector signed int){4294967288,4294967288,4294967288,4294967288});
+  *s32++ = ((vector signed int){4294967289,4294967289,4294967289,4294967289});
+  *s32++ = ((vector signed int){4294967290,4294967290,4294967290,4294967290});
+  *s32++ = ((vector signed int){4294967291,4294967291,4294967291,4294967291});
+  *s32++ = ((vector signed int){4294967292,4294967292,4294967292,4294967292});
+  *s32++ = ((vector signed int){4294967293,4294967293,4294967293,4294967293});
+  *s32++ = ((vector signed int){4294967294,4294967294,4294967294,4294967294});
+  *s32++ = ((vector signed int){4294967295,4294967295,4294967295,4294967295});
+}
+void fs32g(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-252645136,-252645136,-252645136,-252645136});
+  *s32++ = ((vector signed int){-235802127,-235802127,-235802127,-235802127});
+  *s32++ = ((vector signed int){-218959118,-218959118,-218959118,-218959118});
+  *s32++ = ((vector signed int){-202116109,-202116109,-202116109,-202116109});
+  *s32++ = ((vector signed int){-185273100,-185273100,-185273100,-185273100});
+  *s32++ = ((vector signed int){-168430091,-168430091,-168430091,-168430091});
+  *s32++ = ((vector signed int){-151587082,-151587082,-151587082,-151587082});
+  *s32++ = ((vector signed int){-134744073,-134744073,-134744073,-134744073});
+  *s32++ = ((vector signed int){-117901064,-117901064,-117901064,-117901064});
+  *s32++ = ((vector signed int){-101058055,-101058055,-101058055,-101058055});
+  *s32++ = ((vector signed int){-84215046,-84215046,-84215046,-84215046});
+  *s32++ = ((vector signed int){-67372037,-67372037,-67372037,-67372037});
+  *s32++ = ((vector signed int){-50529028,-50529028,-50529028,-50529028});
+  *s32++ = ((vector signed int){-33686019,-33686019,-33686019,-33686019});
+  *s32++ = ((vector signed int){-16843010,-16843010,-16843010,-16843010});
+}
+void fs32h(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-983056,-983056,-983056,-983056});
+  *s32++ = ((vector signed int){-917519,-917519,-917519,-917519});
+  *s32++ = ((vector signed int){-851982,-851982,-851982,-851982});
+  *s32++ = ((vector signed int){-786445,-786445,-786445,-786445});
+  *s32++ = ((vector signed int){-720908,-720908,-720908,-720908});
+  *s32++ = ((vector signed int){-655371,-655371,-655371,-655371});
+  *s32++ = ((vector signed int){-589834,-589834,-589834,-589834});
+  *s32++ = ((vector signed int){-524297,-524297,-524297,-524297});
+  *s32++ = ((vector signed int){-458760,-458760,-458760,-458760});
+  *s32++ = ((vector signed int){-393223,-393223,-393223,-393223});
+  *s32++ = ((vector signed int){-327686,-327686,-327686,-327686});
+  *s32++ = ((vector signed int){-262149,-262149,-262149,-262149});
+  *s32++ = ((vector signed int){-196612,-196612,-196612,-196612});
+  *s32++ = ((vector signed int){-131075,-131075,-131075,-131075});
+  *s32++ = ((vector signed int){-65538,-65538,-65538,-65538});
+}
+void fs32i(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-16,-16,-16,-16});
+  *s32++ = ((vector signed int){-15,-15,-15,-15});
+  *s32++ = ((vector signed int){-14,-14,-14,-14});
+  *s32++ = ((vector signed int){-13,-13,-13,-13});
+  *s32++ = ((vector signed int){-12,-12,-12,-12});
+  *s32++ = ((vector signed int){-11,-11,-11,-11});
+  *s32++ = ((vector signed int){-10,-10,-10,-10});
+  *s32++ = ((vector signed int){-9,-9,-9,-9});
+  *s32++ = ((vector signed int){-8,-8,-8,-8});
+  *s32++ = ((vector signed int){-7,-7,-7,-7});
+  *s32++ = ((vector signed int){-6,-6,-6,-6});
+  *s32++ = ((vector signed int){-5,-5,-5,-5});
+  *s32++ = ((vector signed int){-4,-4,-4,-4});
+  *s32++ = ((vector signed int){-3,-3,-3,-3});
+  *s32++ = ((vector signed int){-2,-2,-2,-2});
+  *s32++ = ((vector signed int){-1,-1,-1,-1});
+}
+void fs32j(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xfffffff0,0xfffffff0,0xfffffff0,0xfffffff0});
+  *s32++ = ((vector signed int){0xfffffff1,0xfffffff1,0xfffffff1,0xfffffff1});
+  *s32++ = ((vector signed int){0xfffffff2,0xfffffff2,0xfffffff2,0xfffffff2});
+  *s32++ = ((vector signed int){0xfffffff3,0xfffffff3,0xfffffff3,0xfffffff3});
+  *s32++ = ((vector signed int){0xfffffff4,0xfffffff4,0xfffffff4,0xfffffff4});
+  *s32++ = ((vector signed int){0xfffffff5,0xfffffff5,0xfffffff5,0xfffffff5});
+  *s32++ = ((vector signed int){0xfffffff6,0xfffffff6,0xfffffff6,0xfffffff6});
+  *s32++ = ((vector signed int){0xfffffff7,0xfffffff7,0xfffffff7,0xfffffff7});
+  *s32++ = ((vector signed int){0xfffffff8,0xfffffff8,0xfffffff8,0xfffffff8});
+  *s32++ = ((vector signed int){0xfffffff9,0xfffffff9,0xfffffff9,0xfffffff9});
+  *s32++ = ((vector signed int){0xfffffffa,0xfffffffa,0xfffffffa,0xfffffffa});
+  *s32++ = ((vector signed int){0xfffffffb,0xfffffffb,0xfffffffb,0xfffffffb});
+  *s32++ = ((vector signed int){0xfffffffc,0xfffffffc,0xfffffffc,0xfffffffc});
+  *s32++ = ((vector signed int){0xfffffffd,0xfffffffd,0xfffffffd,0xfffffffd});
+  *s32++ = ((vector signed int){0xfffffffe,0xfffffffe,0xfffffffe,0xfffffffe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32k(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x00000001,0x00000001,0x00000001,0x00000001});
+  *s32++ = ((vector signed int){0x00000002,0x00000002,0x00000002,0x00000002});
+  *s32++ = ((vector signed int){0x00000003,0x00000003,0x00000003,0x00000003});
+  *s32++ = ((vector signed int){0x00000004,0x00000004,0x00000004,0x00000004});
+  *s32++ = ((vector signed int){0x00000005,0x00000005,0x00000005,0x00000005});
+  *s32++ = ((vector signed int){0x00000006,0x00000006,0x00000006,0x00000006});
+  *s32++ = ((vector signed int){0x00000007,0x00000007,0x00000007,0x00000007});
+  *s32++ = ((vector signed int){0x00000008,0x00000008,0x00000008,0x00000008});
+  *s32++ = ((vector signed int){0x00000009,0x00000009,0x00000009,0x00000009});
+  *s32++ = ((vector signed int){0x0000000a,0x0000000a,0x0000000a,0x0000000a});
+  *s32++ = ((vector signed int){0x0000000b,0x0000000b,0x0000000b,0x0000000b});
+  *s32++ = ((vector signed int){0x0000000c,0x0000000c,0x0000000c,0x0000000c});
+  *s32++ = ((vector signed int){0x0000000d,0x0000000d,0x0000000d,0x0000000d});
+  *s32++ = ((vector signed int){0x0000000e,0x0000000e,0x0000000e,0x0000000e});
+  *s32++ = ((vector signed int){0x0000000f,0x0000000f,0x0000000f,0x0000000f});
+}
+void fs32l(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xfff0fff0,0xfff0fff0,0xfff0fff0,0xfff0fff0});
+  *s32++ = ((vector signed int){0xfff1fff1,0xfff1fff1,0xfff1fff1,0xfff1fff1});
+  *s32++ = ((vector signed int){0xfff2fff2,0xfff2fff2,0xfff2fff2,0xfff2fff2});
+  *s32++ = ((vector signed int){0xfff3fff3,0xfff3fff3,0xfff3fff3,0xfff3fff3});
+  *s32++ = ((vector signed int){0xfff4fff4,0xfff4fff4,0xfff4fff4,0xfff4fff4});
+  *s32++ = ((vector signed int){0xfff5fff5,0xfff5fff5,0xfff5fff5,0xfff5fff5});
+  *s32++ = ((vector signed int){0xfff6fff6,0xfff6fff6,0xfff6fff6,0xfff6fff6});
+  *s32++ = ((vector signed int){0xfff7fff7,0xfff7fff7,0xfff7fff7,0xfff7fff7});
+  *s32++ = ((vector signed int){0xfff8fff8,0xfff8fff8,0xfff8fff8,0xfff8fff8});
+  *s32++ = ((vector signed int){0xfff9fff9,0xfff9fff9,0xfff9fff9,0xfff9fff9});
+  *s32++ = ((vector signed int){0xfffafffa,0xfffafffa,0xfffafffa,0xfffafffa});
+  *s32++ = ((vector signed int){0xfffbfffb,0xfffbfffb,0xfffbfffb,0xfffbfffb});
+  *s32++ = ((vector signed int){0xfffcfffc,0xfffcfffc,0xfffcfffc,0xfffcfffc});
+  *s32++ = ((vector signed int){0xfffdfffd,0xfffdfffd,0xfffdfffd,0xfffdfffd});
+  *s32++ = ((vector signed int){0xfffefffe,0xfffefffe,0xfffefffe,0xfffefffe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32m(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x00010001,0x00010001,0x00010001,0x00010001});
+  *s32++ = ((vector signed int){0x00020002,0x00020002,0x00020002,0x00020002});
+  *s32++ = ((vector signed int){0x00030003,0x00030003,0x00030003,0x00030003});
+  *s32++ = ((vector signed int){0x00040004,0x00040004,0x00040004,0x00040004});
+  *s32++ = ((vector signed int){0x00050005,0x00050005,0x00050005,0x00050005});
+  *s32++ = ((vector signed int){0x00060006,0x00060006,0x00060006,0x00060006});
+  *s32++ = ((vector signed int){0x00070007,0x00070007,0x00070007,0x00070007});
+  *s32++ = ((vector signed int){0x00080008,0x00080008,0x00080008,0x00080008});
+  *s32++ = ((vector signed int){0x00090009,0x00090009,0x00090009,0x00090009});
+  *s32++ = ((vector signed int){0x000a000a,0x000a000a,0x000a000a,0x000a000a});
+  *s32++ = ((vector signed int){0x000b000b,0x000b000b,0x000b000b,0x000b000b});
+  *s32++ = ((vector signed int){0x000c000c,0x000c000c,0x000c000c,0x000c000c});
+  *s32++ = ((vector signed int){0x000d000d,0x000d000d,0x000d000d,0x000d000d});
+  *s32++ = ((vector signed int){0x000e000e,0x000e000e,0x000e000e,0x000e000e});
+  *s32++ = ((vector signed int){0x000f000f,0x000f000f,0x000f000f,0x000f000f});
+}
+void fs32n(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0});
+  *s32++ = ((vector signed int){0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1});
+  *s32++ = ((vector signed int){0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2});
+  *s32++ = ((vector signed int){0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3});
+  *s32++ = ((vector signed int){0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4});
+  *s32++ = ((vector signed int){0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5});
+  *s32++ = ((vector signed int){0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6});
+  *s32++ = ((vector signed int){0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7});
+  *s32++ = ((vector signed int){0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8});
+  *s32++ = ((vector signed int){0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9});
+  *s32++ = ((vector signed int){0xfafafafa,0xfafafafa,0xfafafafa,0xfafafafa});
+  *s32++ = ((vector signed int){0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb});
+  *s32++ = ((vector signed int){0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc});
+  *s32++ = ((vector signed int){0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd});
+  *s32++ = ((vector signed int){0xfefefefe,0xfefefefe,0xfefefefe,0xfefefefe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32o(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x01010101,0x01010101,0x01010101,0x01010101});
+  *s32++ = ((vector signed int){0x02020202,0x02020202,0x02020202,0x02020202});
+  *s32++ = ((vector signed int){0x03030303,0x03030303,0x03030303,0x03030303});
+  *s32++ = ((vector signed int){0x04040404,0x04040404,0x04040404,0x04040404});
+  *s32++ = ((vector signed int){0x05050505,0x05050505,0x05050505,0x05050505});
+  *s32++ = ((vector signed int){0x06060606,0x06060606,0x06060606,0x06060606});
+  *s32++ = ((vector signed int){0x07070707,0x07070707,0x07070707,0x07070707});
+  *s32++ = ((vector signed int){0x08080808,0x08080808,0x08080808,0x08080808});
+  *s32++ = ((vector signed int){0x09090909,0x09090909,0x09090909,0x09090909});
+  *s32++ = ((vector signed int){0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a});
+  *s32++ = ((vector signed int){0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b});
+  *s32++ = ((vector signed int){0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c});
+  *s32++ = ((vector signed int){0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d});
+  *s32++ = ((vector signed int){0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e});
+  *s32++ = ((vector signed int){0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f});
+}
+void fs16a(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0});
+  *s16++ = ((vector signed short){0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1});
+  *s16++ = ((vector signed short){0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2});
+  *s16++ = ((vector signed short){0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3});
+  *s16++ = ((vector signed short){0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4});
+  *s16++ = ((vector signed short){0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5});
+  *s16++ = ((vector signed short){0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6});
+  *s16++ = ((vector signed short){0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7});
+  *s16++ = ((vector signed short){0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8});
+  *s16++ = ((vector signed short){0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9});
+  *s16++ = ((vector signed short){0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa});
+  *s16++ = ((vector signed short){0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb});
+  *s16++ = ((vector signed short){0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc});
+  *s16++ = ((vector signed short){0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd});
+  *s16++ = ((vector signed short){0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16b(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001});
+  *s16++ = ((vector signed short){0x0000,0x0002,0x0000,0x0002,0x0000,0x0002,0x0000,0x0002});
+  *s16++ = ((vector signed short){0x0000,0x0003,0x0000,0x0003,0x0000,0x0003,0x0000,0x0003});
+  *s16++ = ((vector signed short){0x0000,0x0004,0x0000,0x0004,0x0000,0x0004,0x0000,0x0004});
+  *s16++ = ((vector signed short){0x0000,0x0005,0x0000,0x0005,0x0000,0x0005,0x0000,0x0005});
+  *s16++ = ((vector signed short){0x0000,0x0006,0x0000,0x0006,0x0000,0x0006,0x0000,0x0006});
+  *s16++ = ((vector signed short){0x0000,0x0007,0x0000,0x0007,0x0000,0x0007,0x0000,0x0007});
+  *s16++ = ((vector signed short){0x0000,0x0008,0x0000,0x0008,0x0000,0x0008,0x0000,0x0008});
+  *s16++ = ((vector signed short){0x0000,0x0009,0x0000,0x0009,0x0000,0x0009,0x0000,0x0009});
+  *s16++ = ((vector signed short){0x0000,0x000a,0x0000,0x000a,0x0000,0x000a,0x0000,0x000a});
+  *s16++ = ((vector signed short){0x0000,0x000b,0x0000,0x000b,0x0000,0x000b,0x0000,0x000b});
+  *s16++ = ((vector signed short){0x0000,0x000c,0x0000,0x000c,0x0000,0x000c,0x0000,0x000c});
+  *s16++ = ((vector signed short){0x0000,0x000d,0x0000,0x000d,0x0000,0x000d,0x0000,0x000d});
+  *s16++ = ((vector signed short){0x0000,0x000e,0x0000,0x000e,0x0000,0x000e,0x0000,0x000e});
+  *s16++ = ((vector signed short){0x0000,0x000f,0x0000,0x000f,0x0000,0x000f,0x0000,0x000f});
+}
+void fs16c(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0});
+  *s16++ = ((vector signed short){0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1});
+  *s16++ = ((vector signed short){0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2});
+  *s16++ = ((vector signed short){0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3});
+  *s16++ = ((vector signed short){0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4});
+  *s16++ = ((vector signed short){0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5});
+  *s16++ = ((vector signed short){0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6});
+  *s16++ = ((vector signed short){0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7});
+  *s16++ = ((vector signed short){0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8});
+  *s16++ = ((vector signed short){0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9});
+  *s16++ = ((vector signed short){0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa});
+  *s16++ = ((vector signed short){0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb});
+  *s16++ = ((vector signed short){0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc});
+  *s16++ = ((vector signed short){0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd});
+  *s16++ = ((vector signed short){0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16d(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001});
+  *s16++ = ((vector signed short){0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002});
+  *s16++ = ((vector signed short){0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003});
+  *s16++ = ((vector signed short){0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004});
+  *s16++ = ((vector signed short){0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005});
+  *s16++ = ((vector signed short){0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006});
+  *s16++ = ((vector signed short){0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007});
+  *s16++ = ((vector signed short){0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008});
+  *s16++ = ((vector signed short){0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009});
+  *s16++ = ((vector signed short){0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a});
+  *s16++ = ((vector signed short){0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b});
+  *s16++ = ((vector signed short){0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c});
+  *s16++ = ((vector signed short){0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d});
+  *s16++ = ((vector signed short){0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e});
+  *s16++ = ((vector signed short){0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f});
+}
+void fs16e(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0});
+  *s16++ = ((vector signed short){0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1});
+  *s16++ = ((vector signed short){0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2});
+  *s16++ = ((vector signed short){0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3});
+  *s16++ = ((vector signed short){0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4});
+  *s16++ = ((vector signed short){0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5});
+  *s16++ = ((vector signed short){0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6});
+  *s16++ = ((vector signed short){0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7});
+  *s16++ = ((vector signed short){0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8});
+  *s16++ = ((vector signed short){0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9});
+  *s16++ = ((vector signed short){0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa});
+  *s16++ = ((vector signed short){0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb});
+  *s16++ = ((vector signed short){0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc});
+  *s16++ = ((vector signed short){0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd});
+  *s16++ = ((vector signed short){0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16f(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101});
+  *s16++ = ((vector signed short){0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202});
+  *s16++ = ((vector signed short){0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303});
+  *s16++ = ((vector signed short){0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404});
+  *s16++ = ((vector signed short){0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505});
+  *s16++ = ((vector signed short){0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606});
+  *s16++ = ((vector signed short){0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707});
+  *s16++ = ((vector signed short){0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808});
+  *s16++ = ((vector signed short){0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909});
+  *s16++ = ((vector signed short){0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a});
+  *s16++ = ((vector signed short){0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b});
+  *s16++ = ((vector signed short){0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c});
+  *s16++ = ((vector signed short){0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d});
+  *s16++ = ((vector signed short){0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e});
+  *s16++ = ((vector signed short){0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f});
+}
+void fs16g(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0,0,0,0,0,0,0,0});
+  *s16++ = ((vector signed short){1,1,1,1,1,1,1,1});
+  *s16++ = ((vector signed short){2,2,2,2,2,2,2,2});
+  *s16++ = ((vector signed short){3,3,3,3,3,3,3,3});
+  *s16++ = ((vector signed short){4,4,4,4,4,4,4,4});
+  *s16++ = ((vector signed short){5,5,5,5,5,5,5,5});
+  *s16++ = ((vector signed short){6,6,6,6,6,6,6,6});
+  *s16++ = ((vector signed short){7,7,7,7,7,7,7,7});
+  *s16++ = ((vector signed short){8,8,8,8,8,8,8,8});
+  *s16++ = ((vector signed short){9,9,9,9,9,9,9,9});
+  *s16++ = ((vector signed short){10,10,10,10,10,10,10,10});
+  *s16++ = ((vector signed short){11,11,11,11,11,11,11,11});
+  *s16++ = ((vector signed short){12,12,12,12,12,12,12,12});
+  *s16++ = ((vector signed short){13,13,13,13,13,13,13,13});
+  *s16++ = ((vector signed short){14,14,14,14,14,14,14,14});
+  *s16++ = ((vector signed short){15,15,15,15,15,15,15,15});
+}
+void fs16h(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){257,257,257,257,257,257,257,257});
+  *s16++ = ((vector signed short){514,514,514,514,514,514,514,514});
+  *s16++ = ((vector signed short){771,771,771,771,771,771,771,771});
+  *s16++ = ((vector signed short){1028,1028,1028,1028,1028,1028,1028,1028});
+  *s16++ = ((vector signed short){1285,1285,1285,1285,1285,1285,1285,1285});
+  *s16++ = ((vector signed short){1542,1542,1542,1542,1542,1542,1542,1542});
+  *s16++ = ((vector signed short){1799,1799,1799,1799,1799,1799,1799,1799});
+  *s16++ = ((vector signed short){2056,2056,2056,2056,2056,2056,2056,2056});
+  *s16++ = ((vector signed short){2313,2313,2313,2313,2313,2313,2313,2313});
+  *s16++ = ((vector signed short){2570,2570,2570,2570,2570,2570,2570,2570});
+  *s16++ = ((vector signed short){2827,2827,2827,2827,2827,2827,2827,2827});
+  *s16++ = ((vector signed short){3084,3084,3084,3084,3084,3084,3084,3084});
+  *s16++ = ((vector signed short){3341,3341,3341,3341,3341,3341,3341,3341});
+  *s16++ = ((vector signed short){3598,3598,3598,3598,3598,3598,3598,3598});
+  *s16++ = ((vector signed short){3855,3855,3855,3855,3855,3855,3855,3855});
+}
+void fs16i(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){61680,61680,61680,61680,61680,61680,61680,61680});
+  *s16++ = ((vector signed short){61937,61937,61937,61937,61937,61937,61937,61937});
+  *s16++ = ((vector signed short){62194,62194,62194,62194,62194,62194,62194,62194});
+  *s16++ = ((vector signed short){62451,62451,62451,62451,62451,62451,62451,62451});
+  *s16++ = ((vector signed short){62708,62708,62708,62708,62708,62708,62708,62708});
+  *s16++ = ((vector signed short){62965,62965,62965,62965,62965,62965,62965,62965});
+  *s16++ = ((vector signed short){63222,63222,63222,63222,63222,63222,63222,63222});
+  *s16++ = ((vector signed short){63479,63479,63479,63479,63479,63479,63479,63479});
+  *s16++ = ((vector signed short){63736,63736,63736,63736,63736,63736,63736,63736});
+  *s16++ = ((vector signed short){63993,63993,63993,63993,63993,63993,63993,63993});
+  *s16++ = ((vector signed short){64250,64250,64250,64250,64250,64250,64250,64250});
+  *s16++ = ((vector signed short){64507,64507,64507,64507,64507,64507,64507,64507});
+  *s16++ = ((vector signed short){64764,64764,64764,64764,64764,64764,64764,64764});
+  *s16++ = ((vector signed short){65021,65021,65021,65021,65021,65021,65021,65021});
+  *s16++ = ((vector signed short){65278,65278,65278,65278,65278,65278,65278,65278});
+}
+void fs16j(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){65520,65520,65520,65520,65520,65520,65520,65520});
+  *s16++ = ((vector signed short){65521,65521,65521,65521,65521,65521,65521,65521});
+  *s16++ = ((vector signed short){65522,65522,65522,65522,65522,65522,65522,65522});
+  *s16++ = ((vector signed short){65523,65523,65523,65523,65523,65523,65523,65523});
+  *s16++ = ((vector signed short){65524,65524,65524,65524,65524,65524,65524,65524});
+  *s16++ = ((vector signed short){65525,65525,65525,65525,65525,65525,65525,65525});
+  *s16++ = ((vector signed short){65526,65526,65526,65526,65526,65526,65526,65526});
+  *s16++ = ((vector signed short){65527,65527,65527,65527,65527,65527,65527,65527});
+  *s16++ = ((vector signed short){65528,65528,65528,65528,65528,65528,65528,65528});
+  *s16++ = ((vector signed short){65529,65529,65529,65529,65529,65529,65529,65529});
+  *s16++ = ((vector signed short){65530,65530,65530,65530,65530,65530,65530,65530});
+  *s16++ = ((vector signed short){65531,65531,65531,65531,65531,65531,65531,65531});
+  *s16++ = ((vector signed short){65532,65532,65532,65532,65532,65532,65532,65532});
+  *s16++ = ((vector signed short){65533,65533,65533,65533,65533,65533,65533,65533});
+  *s16++ = ((vector signed short){65534,65534,65534,65534,65534,65534,65534,65534});
+  *s16++ = ((vector signed short){65535,65535,65535,65535,65535,65535,65535,65535});
+}
+void fs16k(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){-3856,-3856,-3856,-3856,-3856,-3856,-3856,-3856});
+  *s16++ = ((vector signed short){-3599,-3599,-3599,-3599,-3599,-3599,-3599,-3599});
+  *s16++ = ((vector signed short){-3342,-3342,-3342,-3342,-3342,-3342,-3342,-3342});
+  *s16++ = ((vector signed short){-3085,-3085,-3085,-3085,-3085,-3085,-3085,-3085});
+  *s16++ = ((vector signed short){-2828,-2828,-2828,-2828,-2828,-2828,-2828,-2828});
+  *s16++ = ((vector signed short){-2571,-2571,-2571,-2571,-2571,-2571,-2571,-2571});
+  *s16++ = ((vector signed short){-2314,-2314,-2314,-2314,-2314,-2314,-2314,-2314});
+  *s16++ = ((vector signed short){-2057,-2057,-2057,-2057,-2057,-2057,-2057,-2057});
+  *s16++ = ((vector signed short){-1800,-1800,-1800,-1800,-1800,-1800,-1800,-1800});
+  *s16++ = ((vector signed short){-1543,-1543,-1543,-1543,-1543,-1543,-1543,-1543});
+  *s16++ = ((vector signed short){-1286,-1286,-1286,-1286,-1286,-1286,-1286,-1286});
+  *s16++ = ((vector signed short){-1029,-1029,-1029,-1029,-1029,-1029,-1029,-1029});
+  *s16++ = ((vector signed short){-772,-772,-772,-772,-772,-772,-772,-772});
+  *s16++ = ((vector signed short){-515,-515,-515,-515,-515,-515,-515,-515});
+  *s16++ = ((vector signed short){-258,-258,-258,-258,-258,-258,-258,-258});
+}
+void fs16l(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){-16,-16,-16,-16,-16,-16,-16,-16});
+  *s16++ = ((vector signed short){-15,-15,-15,-15,-15,-15,-15,-15});
+  *s16++ = ((vector signed short){-14,-14,-14,-14,-14,-14,-14,-14});
+  *s16++ = ((vector signed short){-13,-13,-13,-13,-13,-13,-13,-13});
+  *s16++ = ((vector signed short){-12,-12,-12,-12,-12,-12,-12,-12});
+  *s16++ = ((vector signed short){-11,-11,-11,-11,-11,-11,-11,-11});
+  *s16++ = ((vector signed short){-10,-10,-10,-10,-10,-10,-10,-10});
+  *s16++ = ((vector signed short){-9,-9,-9,-9,-9,-9,-9,-9});
+  *s16++ = ((vector signed short){-8,-8,-8,-8,-8,-8,-8,-8});
+  *s16++ = ((vector signed short){-7,-7,-7,-7,-7,-7,-7,-7});
+  *s16++ = ((vector signed short){-6,-6,-6,-6,-6,-6,-6,-6});
+  *s16++ = ((vector signed short){-5,-5,-5,-5,-5,-5,-5,-5});
+  *s16++ = ((vector signed short){-4,-4,-4,-4,-4,-4,-4,-4});
+  *s16++ = ((vector signed short){-3,-3,-3,-3,-3,-3,-3,-3});
+  *s16++ = ((vector signed short){-2,-2,-2,-2,-2,-2,-2,-2});
+  *s16++ = ((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1});
+}
+void fs8a(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8b(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f});
+}
+void fs8c(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0});
+  *s8++ = ((vector signed char){0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1});
+  *s8++ = ((vector signed char){0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2});
+  *s8++ = ((vector signed char){0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3});
+  *s8++ = ((vector signed char){0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4});
+  *s8++ = ((vector signed char){0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5});
+  *s8++ = ((vector signed char){0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6});
+  *s8++ = ((vector signed char){0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7});
+  *s8++ = ((vector signed char){0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8});
+  *s8++ = ((vector signed char){0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9});
+  *s8++ = ((vector signed char){0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa});
+  *s8++ = ((vector signed char){0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb});
+  *s8++ = ((vector signed char){0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc});
+  *s8++ = ((vector signed char){0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd});
+  *s8++ = ((vector signed char){0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8d(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01});
+  *s8++ = ((vector signed char){0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02});
+  *s8++ = ((vector signed char){0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03});
+  *s8++ = ((vector signed char){0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04});
+  *s8++ = ((vector signed char){0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05});
+  *s8++ = ((vector signed char){0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06});
+  *s8++ = ((vector signed char){0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07});
+  *s8++ = ((vector signed char){0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08});
+  *s8++ = ((vector signed char){0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09});
+  *s8++ = ((vector signed char){0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a});
+  *s8++ = ((vector signed char){0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b});
+  *s8++ = ((vector signed char){0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c});
+  *s8++ = ((vector signed char){0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d});
+  *s8++ = ((vector signed char){0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e});
+  *s8++ = ((vector signed char){0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f});
+}
+void fs8e(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01});
+  *s8++ = ((vector signed char){0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02});
+  *s8++ = ((vector signed char){0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03});
+  *s8++ = ((vector signed char){0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04});
+  *s8++ = ((vector signed char){0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05});
+  *s8++ = ((vector signed char){0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06});
+  *s8++ = ((vector signed char){0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07});
+  *s8++ = ((vector signed char){0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08});
+  *s8++ = ((vector signed char){0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09});
+  *s8++ = ((vector signed char){0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a});
+  *s8++ = ((vector signed char){0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b});
+  *s8++ = ((vector signed char){0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c});
+  *s8++ = ((vector signed char){0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d});
+  *s8++ = ((vector signed char){0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e});
+  *s8++ = ((vector signed char){0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f});
+}
+void fs8f(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0});
+  *s8++ = ((vector signed char){0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1});
+  *s8++ = ((vector signed char){0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2});
+  *s8++ = ((vector signed char){0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3});
+  *s8++ = ((vector signed char){0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4});
+  *s8++ = ((vector signed char){0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5});
+  *s8++ = ((vector signed char){0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6});
+  *s8++ = ((vector signed char){0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7});
+  *s8++ = ((vector signed char){0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8});
+  *s8++ = ((vector signed char){0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9});
+  *s8++ = ((vector signed char){0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa});
+  *s8++ = ((vector signed char){0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb});
+  *s8++ = ((vector signed char){0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc});
+  *s8++ = ((vector signed char){0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd});
+  *s8++ = ((vector signed char){0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8g(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0});
+  *s8++ = ((vector signed char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  *s8++ = ((vector signed char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2});
+  *s8++ = ((vector signed char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  *s8++ = ((vector signed char){4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4});
+  *s8++ = ((vector signed char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  *s8++ = ((vector signed char){6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6});
+  *s8++ = ((vector signed char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+  *s8++ = ((vector signed char){8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8});
+  *s8++ = ((vector signed char){9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9});
+  *s8++ = ((vector signed char){10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10});
+  *s8++ = ((vector signed char){11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11});
+  *s8++ = ((vector signed char){12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12});
+  *s8++ = ((vector signed char){13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13});
+  *s8++ = ((vector signed char){14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14});
+  *s8++ = ((vector signed char){15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15});
+}
+void fs8h(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240});
+  *s8++ = ((vector signed char){241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241});
+  *s8++ = ((vector signed char){242,242,242,242,242,242,242,242,242,242,242,242,242,242,242,242});
+  *s8++ = ((vector signed char){243,243,243,243,243,243,243,243,243,243,243,243,243,243,243,243});
+  *s8++ = ((vector signed char){244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244});
+  *s8++ = ((vector signed char){245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245});
+  *s8++ = ((vector signed char){246,246,246,246,246,246,246,246,246,246,246,246,246,246,246,246});
+  *s8++ = ((vector signed char){247,247,247,247,247,247,247,247,247,247,247,247,247,247,247,247});
+  *s8++ = ((vector signed char){248,248,248,248,248,248,248,248,248,248,248,248,248,248,248,248});
+  *s8++ = ((vector signed char){249,249,249,249,249,249,249,249,249,249,249,249,249,249,249,249});
+  *s8++ = ((vector signed char){250,250,250,250,250,250,250,250,250,250,250,250,250,250,250,250});
+  *s8++ = ((vector signed char){251,251,251,251,251,251,251,251,251,251,251,251,251,251,251,251});
+  *s8++ = ((vector signed char){252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252});
+  *s8++ = ((vector signed char){253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253});
+  *s8++ = ((vector signed char){254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,254});
+  *s8++ = ((vector signed char){255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255});
+}
+void fs8i(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1});
+  *s8++ = ((vector signed char){-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2});
+  *s8++ = ((vector signed char){-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3});
+  *s8++ = ((vector signed char){-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4});
+  *s8++ = ((vector signed char){-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5});
+  *s8++ = ((vector signed char){-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6});
+  *s8++ = ((vector signed char){-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7});
+  *s8++ = ((vector signed char){-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8});
+  *s8++ = ((vector signed char){-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9});
+  *s8++ = ((vector signed char){-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10});
+  *s8++ = ((vector signed char){-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11});
+  *s8++ = ((vector signed char){-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12});
+  *s8++ = ((vector signed char){-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13});
+  *s8++ = ((vector signed char){-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14});
+  *s8++ = ((vector signed char){-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15});
+  *s8++ = ((vector signed char){-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16});
+}